a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HiggsThObservables.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2019 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
9#include "NPbase.h"
10
11muggH::muggH(const StandardModel& SM_i, const double sqrt_s_i)
12: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13{
14 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
15 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
16}
17
19{
20 return myNPbase->muggH(sqrt_s);
21}
22
23muVBF::muVBF(const StandardModel& SM_i, const double sqrt_s_i)
24: ThObservable(SM_i), sqrt_s(sqrt_s_i)
25{
26 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
27 throw std::runtime_error("muVBF called with a class whose parent is not NPbase");
28
29}
30
32{
33 return myNPbase->muVBF(sqrt_s);
34}
35
36muVBFgamma::muVBFgamma(const StandardModel& SM_i, const double sqrt_s_i)
37: ThObservable(SM_i), sqrt_s(sqrt_s_i)
38{
39 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
40 throw std::runtime_error("muVBFgamma called with a class whose parent is not NPbase");
41
42}
43
45{
46 return myNPbase->muVBFgamma(sqrt_s);
47}
48
49mueeWBF::mueeWBF(const StandardModel& SM_i, const double sqrt_s_i)
50: ThObservable(SM_i), sqrt_s(sqrt_s_i)
51{
52 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
53 throw std::runtime_error("mueeWBF called with a class whose parent is not NPbase");
54
55}
56
58{
59 return myNPbase->mueeWBF(sqrt_s);
60}
61
62mueeWBFPol::mueeWBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
63: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
64{
65 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
66 throw std::runtime_error("mueeWBFPol called with a class whose parent is not NPbase");
67}
68
70{
72}
73
74mueeHvv::mueeHvv(const StandardModel& SM_i, const double sqrt_s_i)
75: ThObservable(SM_i), sqrt_s(sqrt_s_i)
76{
77 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
78 throw std::runtime_error("mueeHvv called with a class whose parent is not NPbase");
79}
80
82{
83 return myNPbase->mueeHvv(sqrt_s);
84}
85
86mueeHvvPol::mueeHvvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
87: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
88{
89 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
90 throw std::runtime_error("mueeHvvPol called with a class whose parent is not NPbase");
91}
92
94{
96}
97
98mueeZBF::mueeZBF(const StandardModel& SM_i, const double sqrt_s_i)
99: ThObservable(SM_i), sqrt_s(sqrt_s_i)
100{
101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
102 throw std::runtime_error("mueeZBF called with a class whose parent is not NPbase");
103
104}
105
107{
108 return myNPbase->mueeZBF(sqrt_s);
109}
110
111mueeZBFPol::mueeZBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
112: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
113{
114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
115 throw std::runtime_error("mueeZBFPol called with a class whose parent is not NPbase");
116}
117
119{
121}
122
123muepWBF::muepWBF(const StandardModel& SM_i, const double sqrt_s_i)
124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
125{
126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
127 throw std::runtime_error("muepWBF called with a class whose parent is not NPbase");
128
129}
130
132{
133 return myNPbase->muepWBF(sqrt_s);
134}
135
136muWH::muWH(const StandardModel& SM_i, const double sqrt_s_i)
137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
138{
139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
140 throw std::runtime_error("muWH called with a class whose parent is not NPbase");
141}
142
144{
145 return myNPbase->muWH(sqrt_s);
146}
147
148muWHpT250::muWHpT250(const StandardModel& SM_i, const double sqrt_s_i)
149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
150{
151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
152 throw std::runtime_error("muWHpT250 called with a class whose parent is not NPbase");
153}
154
156{
157 return myNPbase->muWHpT250(sqrt_s);
158}
159
160muepZBF::muepZBF(const StandardModel& SM_i, const double sqrt_s_i)
161: ThObservable(SM_i), sqrt_s(sqrt_s_i)
162{
163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
164 throw std::runtime_error("muepZBF called with a class whose parent is not NPbase");
165
166}
167
169{
170 return myNPbase->muepZBF(sqrt_s);
171}
172
173muZH::muZH(const StandardModel& SM_i, const double sqrt_s_i)
174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
175{
176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
177 throw std::runtime_error("muZH called with a class whose parent is not NPbase");
178}
179
181{
182 return myNPbase->muZH(sqrt_s);
183}
184
185muZHpT250::muZHpT250(const StandardModel& SM_i, const double sqrt_s_i)
186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
187{
188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
189 throw std::runtime_error("muZHpT250 called with a class whose parent is not NPbase");
190}
191
193{
194 return myNPbase->muZHpT250(sqrt_s);
195}
196
197mueeZH::mueeZH(const StandardModel& SM_i, const double sqrt_s_i)
198: ThObservable(SM_i), sqrt_s(sqrt_s_i)
199{
200 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
201 throw std::runtime_error("mueeZH called with a class whose parent is not NPbase");
202}
203
205{
206 return myNPbase->mueeZH(sqrt_s);
207}
208
209mueeZHPol::mueeZHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
210: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
211{
212 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
213 throw std::runtime_error("mueeZHPol called with a class whose parent is not NPbase");
214}
215
217{
219}
220
221mueeZllH::mueeZllH(const StandardModel& SM_i, const double sqrt_s_i)
222: ThObservable(SM_i), sqrt_s(sqrt_s_i)
223{
224 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
225 throw std::runtime_error("mueeZllH called with a class whose parent is not NPbase");
226}
227
229{
230 return myNPbase->mueeZllH(sqrt_s);
231}
232
233mueeZllHPol::mueeZllHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
234: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
235{
236 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
237 throw std::runtime_error("mueeZllHPol called with a class whose parent is not NPbase");
238}
239
241{
243}
244
245mueeZqqH::mueeZqqH(const StandardModel& SM_i, const double sqrt_s_i)
246: ThObservable(SM_i), sqrt_s(sqrt_s_i)
247{
248 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
249 throw std::runtime_error("mueeZqqH called with a class whose parent is not NPbase");
250}
251
253{
254 return myNPbase->mueeZqqH(sqrt_s);
255}
256
257mueeZqqHPol::mueeZqqHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
258: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
259{
260 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
261 throw std::runtime_error("mueeZqqHPol called with a class whose parent is not NPbase");
262}
263
265{
267}
268
269
270aPsk::aPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
271: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
272{
273 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
274 throw std::runtime_error("aPsk called with a class whose parent is not NPbase");
275}
276
278{
280}
281
282
283bPsk::bPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
284: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
285{
286 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
287 throw std::runtime_error("bPsk called with a class whose parent is not NPbase");
288}
289
291{
293}
294
295
296muVH::muVH(const StandardModel& SM_i, const double sqrt_s_i)
297: ThObservable(SM_i), sqrt_s(sqrt_s_i)
298{
299 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
300 throw std::runtime_error("muVH called with a class whose parent is not NPbase");
301}
302
304{
305 return myNPbase->muVH(sqrt_s);
306}
307
308muVHpT250::muVHpT250(const StandardModel& SM_i, const double sqrt_s_i)
309: ThObservable(SM_i), sqrt_s(sqrt_s_i)
310{
311 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
312 throw std::runtime_error("muVHpT250 called with a class whose parent is not NPbase");
313}
314
316{
317 return myNPbase->muVHpT250(sqrt_s);
318}
319
320muVBFpVH::muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i)
321: ThObservable(SM_i), sqrt_s(sqrt_s_i)
322{
323 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
324 throw std::runtime_error("muVBFpVH called with a class whose parent is not NPbase");
325}
326
328{
329 return myNPbase->muVBFpVH(sqrt_s);
330}
331
332muttH::muttH(const StandardModel& SM_i, const double sqrt_s_i)
333: ThObservable(SM_i), sqrt_s(sqrt_s_i)
334{
335 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
336 throw std::runtime_error("muttH called with a class whose parent is not NPbase");
337}
338
340{
341 return myNPbase->muttH(sqrt_s);
342}
343
344mutHq::mutHq(const StandardModel& SM_i, const double sqrt_s_i)
345: ThObservable(SM_i), sqrt_s(sqrt_s_i)
346{
347 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
348 throw std::runtime_error("mutHq called with a class whose parent is not NPbase");
349}
350
352{
353 return myNPbase->mutHq(sqrt_s);
354}
355
356muggHpttH::muggHpttH(const StandardModel& SM_i, const double sqrt_s_i)
357: ThObservable(SM_i), sqrt_s(sqrt_s_i)
358{
359 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
360 throw std::runtime_error("muggHpttH called with a class whose parent is not NPbase");
361}
362
364{
365 return myNPbase->muggHpttH(sqrt_s);
366}
367
368mueettH::mueettH(const StandardModel& SM_i, const double sqrt_s_i)
369: ThObservable(SM_i), sqrt_s(sqrt_s_i)
370{
371 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
372 throw std::runtime_error("mueettH called with a class whose parent is not NPbase");
373
374}
375
377{
378 return myNPbase->mueettH(sqrt_s);
379}
380
381mueettHPol::mueettHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
382: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
383{
384 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
385 throw std::runtime_error("mueettHPol called with a class whose parent is not NPbase");
386}
387
389{
391}
392
393mummH::mummH(const StandardModel& SM_i, const double sqrt_s_i)
394: ThObservable(SM_i), sqrt_s(sqrt_s_i)
395{
396 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
397 throw std::runtime_error("mummH called with a class whose parent is not NPbase");
398}
399
401{
402 return myNPbase->mummH(sqrt_s);
403}
404
405mummHNWA::mummHNWA(const StandardModel& SM_i, const double sqrt_s_i)
406: ThObservable(SM_i), sqrt_s(sqrt_s_i)
407{
408 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
409 throw std::runtime_error("mummHNWA called with a class whose parent is not NPbase");
410}
411
413{
414 return myNPbase->mummHNWA(sqrt_s);
415}
416
418: ThObservable(SM_i)
419{
420 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
421 throw std::runtime_error("GammaHRatio called with a class whose parent is not NPbase");
422}
423
425{
427}
428
430{
431 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
432 throw std::runtime_error("BrHtoinvRatio called with a class whose parent is not NPbase");
433}
434
436{
437 return myNPbase->BrHtoinvRatio();
438}
439
441: ThObservable(SM_i)
442{
443 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
444 throw std::runtime_error("BrHinvisible called with a class whose parent is not NPbase");
445}
446
448{
449 return myNPbase->Br_H_inv();
450}
451
453: ThObservable(SM_i)
454{
455 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
456 throw std::runtime_error("BrHinvisibleNP called with a class whose parent is not NPbase");
457}
458
460{
461 return myNPbase->Br_H_inv_NP();
462}
463
465: ThObservable(SM_i)
466{
467 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
468 throw std::runtime_error("BrHexotic called with a class whose parent is not NPbase");
469}
470
472{
473 return myNPbase->Br_H_exo();
474}
475
477: ThObservable(SM_i)
478{
479 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
480 throw std::runtime_error("BrHtovisRatio called with a class whose parent is not NPbase");
481}
482
484{
485 return myNPbase->BrHvisRatio();
486}
487
489: ThObservable(SM_i)
490{
491 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
492 throw std::runtime_error("BrHtoggRatio called with a class whose parent is not NPbase");
493}
494
496{
497 return myNPbase->BrHggRatio();
498}
499
501: ThObservable(SM_i)
502{
503 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
504 throw std::runtime_error("BrHtoWWRatio called with a class whose parent is not NPbase");
505}
506
508{
509 return myNPbase->BrHWWRatio();
510}
511
513: ThObservable(SM_i)
514{
515 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
516 throw std::runtime_error("BrHtoZZRatio called with a class whose parent is not NPbase");
517}
518
520{
521 return myNPbase->BrHZZRatio();
522}
523
525: ThObservable(SM_i)
526{
527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
528 throw std::runtime_error("BrHtoVVRatio called with a class whose parent is not NPbase");
529}
530
532{
533 return myNPbase->BrHVVRatio();
534}
535
537{
538 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
539 throw std::runtime_error("BrHtoZgaRatio called with a class whose parent is not NPbase");
540}
541
543{
544 return myNPbase->BrHZgaRatio();
545}
546
548{
549 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
550 throw std::runtime_error("BrHtoZgallRatio called with a class whose parent is not NPbase");
551}
552
554{
555 return myNPbase->BrHZgallRatio();
556}
557
559{
560 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
561 throw std::runtime_error("BrHtoZgaeeRatio called with a class whose parent is not NPbase");
562}
563
565{
566 return myNPbase->BrHZgaeeRatio();
567}
568
570{
571 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
572 throw std::runtime_error("BrHtoZgamumuRatio called with a class whose parent is not NPbase");
573}
574
576{
577 return myNPbase->BrHZgamumuRatio();
578}
579
581{
582 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
583 throw std::runtime_error("BrHtogagaRatio called with a class whose parent is not NPbase");
584}
585
587{
588 return myNPbase->BrHgagaRatio();
589}
590
592{
593 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
594 throw std::runtime_error("BrHtomumuRatio called with a class whose parent is not NPbase");
595}
596
598{
599 return myNPbase->BrHmumuRatio();
600}
601
603{
604 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
605 throw std::runtime_error("BrHtotautauRatio called with a class whose parent is not NPbase");
606}
607
609{
610 return myNPbase->BrHtautauRatio();
611}
612
614{
615 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
616 throw std::runtime_error("BrHtoccRatio called with a class whose parent is not NPbase");
617}
618
620{
621 return myNPbase->BrHccRatio();
622}
623
625{
626 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
627 throw std::runtime_error("BrHtobbRatio called with a class whose parent is not NPbase");
628}
629
631{
632 return myNPbase->BrHbbRatio();
633}
634
635// -----------------------------------------------------------------------------
636// More 4 fermion decays
637// -----------------------------------------------------------------------------
638
639
641: ThObservable(SM_i)
642{
643 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
644 throw std::runtime_error("BrHto2l2vRatio called with a class whose parent is not NPbase");
645}
646
648{
649 return myNPbase->BrH2l2vRatio();
650}
651
652
654: ThObservable(SM_i)
655{
656 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
657 throw std::runtime_error("BrHtoevmuvRatio called with a class whose parent is not NPbase");
658}
659
661{
662 return myNPbase->BrHevmuvRatio();
663}
664
665
667: ThObservable(SM_i)
668{
669 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
670 throw std::runtime_error("BrHto2e2vRatio called with a class whose parent is not NPbase");
671}
672
674{
675 // SM decay widths (from MG simulations)
676 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
677
678 // Sum
679 double wH2e2vTSM=wH2e2vSM+wH2evSM;
680
681 return ( (wH2e2vSM*(myNPbase->BrH2e2vRatio()) + wH2evSM*(myNPbase->BrH2evRatio())) / wH2e2vTSM );
682}
683
684
686: ThObservable(SM_i)
687{
688 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
689 throw std::runtime_error("BrHto2mu2vRatio called with a class whose parent is not NPbase");
690}
691
693{
694 // SM decay widths (from MG simulations)
695 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
696
697 // Sum
698 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
699
700 return ( (wH2mu2vSM*(myNPbase->BrH2mu2vRatio()) + wH2muvSM*(myNPbase->BrH2muvRatio())) / wH2mu2vTSM );
701}
702
703
705: ThObservable(SM_i)
706{
707 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
708 throw std::runtime_error("BrHto4lRatio called with a class whose parent is not NPbase");
709}
710
712{
713 return myNPbase->BrH4lRatio();
714}
715
716
718: ThObservable(SM_i)
719{
720 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
721 throw std::runtime_error("BrHto4eRatio called with a class whose parent is not NPbase");
722}
723
725{
726 return myNPbase->BrH4eRatio();
727}
728
729
731: ThObservable(SM_i)
732{
733 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
734 throw std::runtime_error("BrHto4muRatio called with a class whose parent is not NPbase");
735}
736
738{
739 return myNPbase->BrH4muRatio();
740}
741
742
744: ThObservable(SM_i)
745{
746 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
747 throw std::runtime_error("BrHto2e2muRatio called with a class whose parent is not NPbase");
748}
749
751{
752 return myNPbase->BrH2e2muRatio();
753}
754
755
756
758: ThObservable(SM_i)
759{
760 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
761 throw std::runtime_error("BrHtolljjRatio called with a class whose parent is not NPbase");
762}
763
765{
766 return myNPbase->BrHlljjRatio();
767}
768
769
771: ThObservable(SM_i)
772{
773 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
774 throw std::runtime_error("BrHtolvjjRatio called with a class whose parent is not NPbase");
775}
776
778{
779 return myNPbase->BrHlvjjRatio();
780}
781
782
784: ThObservable(SM_i)
785{
786 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
787 throw std::runtime_error("BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
788}
789
791{
792 return myNPbase->BrHlv_lvorjjRatio();
793}
794
795
797: ThObservable(SM_i)
798{
799 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
800 throw std::runtime_error("BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
801}
802
804{
805 return myNPbase->BrHll_vvorjjRatio();
806}
807
808// -----------------------------------------------------------------------------
809// Ratios of BR (ratios with SM)
810// -----------------------------------------------------------------------------
811
813{
814 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
815 throw std::runtime_error("BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
816}
817
819{
820 if ((this->getModel()).isModelLinearized()) {
821 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHmumuRatio()));
822 } else {
823 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHmumuRatio());
824 }
825}
826
828{
829 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
830 throw std::runtime_error("BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
831}
832
834{
835 if ((this->getModel()).isModelLinearized()) {
836 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHmumuRatio()));
837 } else {
838 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHmumuRatio());
839 }
840}
841
843{
844 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
845 throw std::runtime_error("BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
846}
847
849{
850 if ((this->getModel()).isModelLinearized()) {
851 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrHmumuRatio()));
852 } else {
854 }
855}
856
858{
859 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
860 throw std::runtime_error("BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
861}
862
864{
865 if ((this->getModel()).isModelLinearized()) {
866 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH4lRatio()));
867 } else {
868 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH4lRatio());
869 }
870}
871
873{
874 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
875 throw std::runtime_error("BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
876}
877
879{
880 if ((this->getModel()).isModelLinearized()) {
881 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrH4lRatio()));
882 } else {
883 return (myNPbase->BrHbbRatio()) / (myNPbase->BrH4lRatio());
884 }
885}
886
887
889{
890 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
891 throw std::runtime_error("BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
892}
893
895{
896 if ((this->getModel()).isModelLinearized()) {
897 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrH4lRatio()));
898 } else {
899 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrH4lRatio());
900 }
901}
902
903
905{
906 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
907 throw std::runtime_error("BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
908}
909
911{
912 if ((this->getModel()).isModelLinearized()) {
913 return (1.0 + (myNPbase->BrHtautauRatio()) - (myNPbase->BrH4lRatio()));
914 } else {
915 return (myNPbase->BrHtautauRatio()) / (myNPbase->BrH4lRatio());
916 }
917}
918
919
921{
922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
923 throw std::runtime_error("BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
924}
925
927{
928 if ((this->getModel()).isModelLinearized()) {
929 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH2e2muRatio()));
930 } else {
931 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH2e2muRatio());
932 }
933}
934
936{
937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
938 throw std::runtime_error("BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
939}
940
942{
943 if ((this->getModel()).isModelLinearized()) {
944 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4lRatio()));
945 } else {
946 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4lRatio());
947 }
948}
949
951{
952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
953 throw std::runtime_error("BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
954}
955
957{
958 if ((this->getModel()).isModelLinearized()) {
959 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4lRatio()));
960 } else {
961 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4lRatio());
962 }
963}
964
966{
967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
968 throw std::runtime_error("BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
969}
970
972{
973 if ((this->getModel()).isModelLinearized()) {
974 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4muRatio()));
975 } else {
976 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4muRatio());
977 }
978}
979
981{
982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
983 throw std::runtime_error("BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
984}
985
987{
988 if ((this->getModel()).isModelLinearized()) {
989 return (1.0 + (myNPbase->BrH4lRatio()) - (myNPbase->BrHgagaRatio()));
990 } else {
991 return (myNPbase->BrH4lRatio()) / (myNPbase->BrHgagaRatio());
992 }
993}
994
996{
997 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
998 throw std::runtime_error("BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
999}
1000
1002{
1003 if ((this->getModel()).isModelLinearized()) {
1004 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHgagaRatio()));
1005 } else {
1006 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHgagaRatio());
1007 }
1008}
1009
1011{
1012 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1013 throw std::runtime_error("BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1014}
1015
1017{
1018 if ((this->getModel()).isModelLinearized()) {
1019 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrHgagaRatio()));
1020 } else {
1021 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrHgagaRatio());
1022 }
1023}
1024
1025
1027{
1028 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1029 throw std::runtime_error("BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1030}
1031
1033{
1034 if ((this->getModel()).isModelLinearized()) {
1035 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrHgagaRatio()));
1036 } else {
1037 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrHgagaRatio());
1038 }
1039}
1040
1041
1043{
1044 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1045 throw std::runtime_error("BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1046}
1047
1049{
1050 if ((this->getModel()).isModelLinearized()) {
1051 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrHccRatio()));
1052 } else {
1053 return (myNPbase->BrHbbRatio()) / (myNPbase->BrHccRatio());
1054 }
1055}
1056
1057
1059{
1060 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1061 throw std::runtime_error("BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1062}
1063
1065{
1066 if ((this->getModel()).isModelLinearized()) {
1067 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHggRatio()));
1068 } else {
1069 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHggRatio());
1070 }
1071}
1072
1073
1075{
1076 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1077 throw std::runtime_error("BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1078}
1079
1081{
1082 if ((this->getModel()).isModelLinearized()) {
1083 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHbbRatio()));
1084 } else {
1085 return (myNPbase->BrHggRatio()) / (myNPbase->BrHbbRatio());
1086 }
1087}
1088
1089
1091{
1092 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1093 throw std::runtime_error("BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1094}
1095
1097{
1098 if ((this->getModel()).isModelLinearized()) {
1099 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHccRatio()));
1100 } else {
1101 return (myNPbase->BrHggRatio()) / (myNPbase->BrHccRatio());
1102 }
1103}
1104
1105
1106// -----------------------------------------------------------------------------
1107// Full signal strengths (prod x decay)
1108// -----------------------------------------------------------------------------
1109
1110muggHgaga::muggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1111: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1112{
1113 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1114 throw std::runtime_error("muggHgaga called with a class whose parent is not NPbase");
1115}
1116
1118{
1119 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1120 //AG: Most general expression including quadratic corrections.
1121 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1122 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1123 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1124 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1125 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1126 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1127
1128 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1129 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1130 double Br1 = dGammaR1-dGammaRTot1;
1131 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1132 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1133 } else {
1134 return myNPbase->muggHgaga(sqrt_s);
1135 }
1136}
1137
1138muggHgagaInt::muggHgagaInt(const StandardModel& SM_i, const double sqrt_s_i)
1139: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1140{
1141 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1142 throw std::runtime_error("muggHgagaInt called with a class whose parent is not NPbase");
1143}
1144
1146{
1148}
1149
1150muVBFHgaga::muVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1151: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1152{
1153 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1154 throw std::runtime_error("muVBFHgaga called with a class whose parent is not NPbase");
1155}
1156
1158{
1159 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1160 //AG: Most general expression including quadratic corrections.
1161 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1162 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1163 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1164 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1165 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1166 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1167
1168 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1169 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1170 double Br1 = dGammaR1-dGammaRTot1;
1171 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1172 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1173 } else {
1174 return myNPbase->muVBFHgaga(sqrt_s);
1175 }
1176}
1177
1178muZHgaga::muZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1179: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1180{
1181 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1182 throw std::runtime_error("muZHgaga called with a class whose parent is not NPbase");
1183}
1184
1186{
1187 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1188 //AG: Most general expression including quadratic corrections.
1189 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1190 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1191 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1192 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1193 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1194 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1195
1196 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1197 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1198 double Br1 = dGammaR1-dGammaRTot1;
1199 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1200 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1201 } else {
1202 return myNPbase->muZHgaga(sqrt_s);
1203 }
1204}
1205
1206muWHgaga::muWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1207: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1208{
1209 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1210 throw std::runtime_error("muWHgaga called with a class whose parent is not NPbase");
1211}
1212
1214{
1215 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1216 //AG: Most general expression including quadratic corrections.
1217 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1218 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1219 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1220 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1221 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1222 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1223
1224 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1225 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1226 double Br1 = dGammaR1-dGammaRTot1;
1227 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1228 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1229 } else {
1230 return myNPbase->muWHgaga(sqrt_s);
1231 }
1232}
1233
1234muVHgaga::muVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1235: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1236{
1237 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1238 throw std::runtime_error("muVHgaga called with a class whose parent is not NPbase");
1239}
1240
1242{
1243 if ((this->getModel()).isModelLinearized()) {
1244 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1245 } else {
1246 return myNPbase->muVHgaga(sqrt_s);
1247 }
1248}
1249
1250muttHgaga::muttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1251: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1252{
1253 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1254 throw std::runtime_error("muttHgaga called with a class whose parent is not NPbase");
1255}
1256
1258{
1259 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1260 //AG: Most general expression including quadratic corrections.
1261 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1262 //return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1263 double muProd1 = myNPbase->delta_muttH_1(sqrt_s);
1264 double muProd2 = myNPbase->delta_muttH_2(sqrt_s);
1265 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1266 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1267
1268 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1269 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1270 double Br1 = dGammaR1-dGammaRTot1;
1271 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1272 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1273 } else {
1274 return myNPbase->muttHgaga(sqrt_s);
1275 }
1276}
1277
1278mutHgaga::mutHgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1279: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1280{
1281 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1282 throw std::runtime_error("mutHgaga called with a class whose parent is not NPbase");
1283}
1284
1286{
1287 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1288 //AG: Most general expression including quadratic corrections.
1289 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1290 double muProd1 = myNPbase->delta_mutH_1(sqrt_s);
1291 double muProd2 = myNPbase->delta_mutH_2(sqrt_s);
1292 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1293 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1294
1295 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1296 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1297 double Br1 = dGammaR1-dGammaRTot1;
1298 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1299 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1300 } else {
1301 //VM: Just in case someone wants to add directly the production*decay
1302 //(which is the observable we fit at the end)
1303 double NPmutHgaga = myNPbase->mutHgaga(sqrt_s);
1304 if(NPmutHgaga==1.0){
1305 return ((myNPbase->mutH(sqrt_s)) )*(myNPbase->BrHgagaRatio());
1306 } else{
1307 return NPmutHgaga;
1308 }
1309 }
1310}
1311
1312muggHpbbH_Hgaga::muggHpbbH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1313: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1314{
1315 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1316 throw std::runtime_error("muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1317}
1318
1320{
1321 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1322 //AG: Most general expression including quadratic corrections.
1323 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1324 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1325 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1326 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1327 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1328
1329 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1330 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1331 double Br1 = dGammaR1-dGammaRTot1;
1332 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1333 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1334 } else {
1335 //VM: Just in case someone wants to add directly the production*decay
1336 //(which is the observable we fit at the end)
1337 //Also, the bbH is missing here, I'll leave it as it was for the
1338 //moment (since bbH is really suppressed).
1339 double NPmuggHpbbH_Hgaga = myNPbase->muggHpbbH_Hgaga(sqrt_s);
1340 if (NPmuggHpbbH_Hgaga == 1.0){
1341 return (myNPbase->muggHgaga(sqrt_s));
1342 } else{
1343 return NPmuggHpbbH_Hgaga;
1344 }
1345 }
1346}
1347
1348muttHptH_Hgaga::muttHptH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1349: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1350{
1351 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1352 throw std::runtime_error("muttHptH_Hgaga called with a class whose parent is not NPbase");
1353}
1354
1356{
1357 //VM:Note that these values are valid for 13 TeV, they are not general
1358 //We should access the SM function that has all the values (for the
1359 //different energies). The values are slightly different, we should
1360 //check this.
1361 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1362 double xsSM_ttH = 0.499873;
1363 double xsSM_tH = 0.0821;
1364 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1365 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1366
1367 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1368 //AG: Most general expression including quadratic corrections.
1369 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1370 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1371 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1372 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1373 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1374
1375 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1376 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1377 double Br1 = dGammaR1-dGammaRTot1;
1378 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1379 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1380 } else {
1381 //VM: Just in case someone wants to add directly the production*decay
1382 //(which is the observable we fit at the end)
1383 double NPmuttHptH_Hgaga = myNPbase->muttHptH_Hgaga(sqrt_s);
1384 if(NPmuttHptH_Hgaga==1.0){
1385 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHgagaRatio()) ;
1386 } else {
1387 return NPmuttHptH_Hgaga;
1388 }
1389 }
1390}
1391
1392muggHZga::muggHZga(const StandardModel& SM_i, const double sqrt_s_i)
1393: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1394{
1395 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1396 throw std::runtime_error("muggHZga called with a class whose parent is not NPbase");
1397}
1398
1400{
1401 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1402 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1403 //AG: Most general expression including quadratic corrections.
1404 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1405 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1406 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1407 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1408 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1409
1410 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1411 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1412 double Br1 = dGammaR1-dGammaRTot1;
1413 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1414 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1415 } else {
1416 return myNPbase->muggHZga(sqrt_s);
1417 }
1418}
1419
1420muggHZgamumu::muggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
1421: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1422{
1423 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1424 throw std::runtime_error("muggHZgamumu called with a class whose parent is not NPbase");
1425}
1426
1428{
1429 if ((this->getModel()).isModelLinearized()) {
1430 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgamumuRatio()));
1431 } else {
1433 }
1434}
1435
1436muVBFHZga::muVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
1437: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1438{
1439 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1440 throw std::runtime_error("muVBFHZga called with a class whose parent is not NPbase");
1441}
1442
1444{
1445 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1446 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1447 //AG: Most general expression including quadratic corrections.
1448 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1449 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1450 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1451 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1452 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1453
1454 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1455 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1456 double Br1 = dGammaR1-dGammaRTot1;
1457 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1458 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1459 } else {
1460 return myNPbase->muVBFHZga(sqrt_s);
1461 }
1462}
1463
1464muZHZga::muZHZga(const StandardModel& SM_i, const double sqrt_s_i)
1465: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1466{
1467 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1468 throw std::runtime_error("muZHZga called with a class whose parent is not NPbase");
1469}
1470
1472{
1473 if ((this->getModel()).isModelLinearized()) {
1474 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1475 } else {
1476 return myNPbase->muZHZga(sqrt_s);
1477 }
1478}
1479
1480muWHZga::muWHZga(const StandardModel& SM_i, const double sqrt_s_i)
1481: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1482{
1483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1484 throw std::runtime_error("muWHZga called with a class whose parent is not NPbase");
1485}
1486
1488{
1489 if ((this->getModel()).isModelLinearized()) {
1490 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1491 } else {
1492 return myNPbase->muWHZga(sqrt_s);
1493 }
1494}
1495
1496muVHZga::muVHZga(const StandardModel& SM_i, const double sqrt_s_i)
1497: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1498{
1499 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1500 throw std::runtime_error("muVHZga called with a class whose parent is not NPbase");
1501}
1502
1504{
1505 if ((this->getModel()).isModelLinearized()) {
1506 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1507 } else {
1508 return myNPbase->muVHZga(sqrt_s);
1509 }
1510}
1511
1512muttHZga::muttHZga(const StandardModel& SM_i, const double sqrt_s_i)
1513: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1514{
1515 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1516 throw std::runtime_error("muttHZga called with a class whose parent is not NPbase");
1517}
1518
1520{
1521 if ((this->getModel()).isModelLinearized()) {
1522 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1523 } else {
1524 return myNPbase->muttHZga(sqrt_s);
1525 }
1526}
1527
1528muggHZZ::muggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1529: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1530{
1531 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1532 throw std::runtime_error("muggHZZ called with a class whose parent is not NPbase");
1533}
1534
1536{
1537 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1538 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1539 //AG: Most general expression including quadratic corrections.
1540 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1541 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1542 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1543 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1544 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1545
1546 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1547 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1548 double Br1 = dGammaR1-dGammaRTot1;
1549 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1550 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1551 } else {
1552 return myNPbase->muggHZZ(sqrt_s);
1553 }
1554}
1555
1556muVBFHZZ::muVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1557: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1558{
1559 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1560 throw std::runtime_error("muVBFHZZ called with a class whose parent is not NPbase");
1561}
1562
1564{
1565 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1566 //AG: Most general expression including quadratic corrections.
1567 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1568 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZZRatio()));
1569 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1570 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1571 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1572 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1573
1574 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1575 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1576 double Br1 = dGammaR1-dGammaRTot1;
1577 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1578 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1579 } else {
1580 return myNPbase->muVBFHZZ(sqrt_s);
1581 }
1582}
1583
1584muZHZZ::muZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1585: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1586{
1587 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1588 throw std::runtime_error("muZHZZ called with a class whose parent is not NPbase");
1589}
1590
1592{
1593 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1594 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1595 //AG: Most general expression including quadratic corrections.
1596 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1597 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1598 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1599 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1600 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1601
1602 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1603 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1604 double Br1 = dGammaR1-dGammaRTot1;
1605 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1606 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1607 } else {
1608 return myNPbase->muZHZZ(sqrt_s);
1609 }
1610}
1611
1612muWHZZ::muWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1613: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1614{
1615 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1616 throw std::runtime_error("muWHZZ called with a class whose parent is not NPbase");
1617}
1618
1620{
1621 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1622 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1623 //AG: Most general expression including quadratic corrections.
1624 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1625 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1626 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1627 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1628 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1629
1630 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1631 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1632 double Br1 = dGammaR1-dGammaRTot1;
1633 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1634 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1635 } else {
1636 return myNPbase->muWHZZ(sqrt_s);
1637 }
1638}
1639
1640muVHZZ::muVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1641: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1642{
1643 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1644 throw std::runtime_error("muVHZZ called with a class whose parent is not NPbase");
1645}
1646
1648{
1649 //VM:Note that these values are valid for 13 TeV, they are not general
1650 //We should access the SM function that has all the values (for the
1651 //different energies). The values are slightly different, we should
1652 //check this.
1653 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1654 double xsSM_WH = 1.21539;
1655 double xsSM_ZH = 0.795910;
1656 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
1657 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
1658 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1659 //AG: Most general expression including quadratic corrections.
1660 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1661 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1662 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1663 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1664 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1665 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1666
1667 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1668 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1669 double Br1 = dGammaR1-dGammaRTot1;
1670 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1671 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1672 } else {
1673 //return myNPbase->muVHZZ(sqrt_s);
1674 //VM: Just in case someone wants to add directly the production*decay
1675 //(which is the observable we fit at the end)
1676 double NPmuVHZZ = myNPbase->muVHZZ(sqrt_s);
1677 if(NPmuVHZZ==1.0){
1678 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHZZRatio());
1679 } else {
1680 return NPmuVHZZ;
1681 }
1682 }
1683}
1684
1685muttHZZ::muttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1686: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1687{
1688 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1689 throw std::runtime_error("muttHZZ called with a class whose parent is not NPbase");
1690}
1691
1693{
1694 if ((this->getModel()).isModelLinearized()) {
1695 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1696 } else {
1697 return myNPbase->muttHZZ(sqrt_s);
1698 }
1699}
1700
1701muttHptH_HZZ::muttHptH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1702: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1703{
1704 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1705 throw std::runtime_error("muttHptH_HZZ called with a class whose parent is not NPbase");
1706}
1707
1709{
1710 //VM:Note that these values are valid for 13 TeV, they are not general
1711 //We should access the SM function that has all the values (for the
1712 //different energies). The values are slightly different, we should
1713 //check this.
1714 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1715 double xsSM_ttH = 0.499873;
1716 double xsSM_tH = 0.0821;
1717 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1718 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1719 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1720 //AG: Most general expression including quadratic corrections.
1721 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1722 //return ( 1.0 + muProd1 + (myNPbase->BrHZZRatio()-1.) );
1723 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1724 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1725 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1726 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1727
1728 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1729 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1730 double Br1 = dGammaR1-dGammaRTot1;
1731 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1732 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1733 } else {
1734
1735 //VM: Just in case someone wants to add directly the production*decay
1736 //(which is the observable we fit at the end)
1737 double NPmuttHptH_HZZ = myNPbase->muttHptH_HZZ(sqrt_s);
1738 if(NPmuttHptH_HZZ==1.0){
1739 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHZZRatio()) ;
1740 } else {
1741 return NPmuttHptH_HZZ;
1742 }
1743 }
1744}
1745
1746muttHptH_Hmumu::muttHptH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1747: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1748{
1749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1750 throw std::runtime_error("muttHptH_Hmumu called with a class whose parent is not NPbase");
1751}
1752
1754{
1755 //VM:Note that these values are valid for 13 TeV, they are not general
1756 //We should access the SM function that has all the values (for the
1757 //different energies). The values are slightly different, we should
1758 //check this.
1759 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1760 double xsSM_ttH = 0.499873;
1761 double xsSM_tH = 0.0821;
1762 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1763 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1764 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1765 //return ( 1.0
1766 // + ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH)
1767 // + (myNPbase->BrHmumuRatio()-1.));
1768 double muProd1 = ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH);
1769 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1770 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
1771 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
1772
1773 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1774 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1775 double Br1 = dGammaR1-dGammaRTot1;
1776 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1777 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1778 } else {
1779
1780 //VM: Just in case someone wants to add directly the production*decay
1781 //(which is the observable we fit at the end)
1782 double NPmuttHptH_Hmumu = myNPbase->muttHptH_Hmumu(sqrt_s);
1783 if(NPmuttHptH_Hmumu==1.0){
1784 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHmumuRatio());
1785 } else {
1786 return NPmuttHptH_Hmumu;
1787 }
1788 }
1789}
1790
1791muggHpbbH_HZZ::muggHpbbH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1792: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1793{
1794 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1795 throw std::runtime_error("muggHpbbH_HZZ called with a class whose parent is not NPbase");
1796}
1797
1799{
1800 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1801 //AG: Most general expression including quadratic corrections.
1802 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1803 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.));
1804 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1805 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1806 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1807 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1808
1809 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1810 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1811 double Br1 = dGammaR1-dGammaRTot1;
1812 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1813 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1814 } else {
1815 //VM: Just in case someone wants to add directly the production*decay
1816 //(which is the observable we fit at the end)
1817 //Also, the bbH is missing here, I'll leave it as it was for the
1818 //moment (since bbH is really suppressed in the SM).
1819 double NPmuggHpbbH_HZZ = myNPbase->muggHpbbH_HZZ(sqrt_s);
1820 if (NPmuggHpbbH_HZZ == 1.0){
1821 return (myNPbase->muggHZZ(sqrt_s));
1822 } else{
1823 return NPmuggHpbbH_HZZ;
1824 }
1825 }
1826}
1827
1828muggHZZ4l::muggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
1829: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1830{
1831 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1832 throw std::runtime_error("muggHZZ4l called with a class whose parent is not NPbase");
1833}
1834
1836{
1837 if ((this->getModel()).isModelLinearized()) {
1838 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4lRatio()));
1839 } else {
1840 return myNPbase->muggHZZ4l(sqrt_s);
1841 }
1842}
1843
1844muggHZZ4mu::muggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
1845: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1846{
1847 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1848 throw std::runtime_error("muggHZZ4mu called with a class whose parent is not NPbase");
1849}
1850
1852{
1853 if ((this->getModel()).isModelLinearized()) {
1854 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4muRatio()));
1855 } else {
1856 return (myNPbase->muggH(sqrt_s))*(myNPbase->BrH4muRatio());
1857 }
1858}
1859
1860muVBFHZZ4l::muVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
1861: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1862{
1863 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1864 throw std::runtime_error("muVBFHZZ4l called with a class whose parent is not NPbase");
1865}
1866
1868{
1869 if ((this->getModel()).isModelLinearized()) {
1870 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH4lRatio()));
1871 } else {
1872 return myNPbase->muVBFHZZ4l(sqrt_s);
1873 }
1874}
1875
1876muZHZZ4l::muZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
1877: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1878{
1879 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1880 throw std::runtime_error("muZHZZ4l called with a class whose parent is not NPbase");
1881}
1882
1884{
1885 if ((this->getModel()).isModelLinearized()) {
1886 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH4lRatio()));
1887 } else {
1888 return myNPbase->muZHZZ4l(sqrt_s);
1889 }
1890}
1891
1892muWHZZ4l::muWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
1893: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1894{
1895 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1896 throw std::runtime_error("muWHZZ4l called with a class whose parent is not NPbase");
1897}
1898
1900{
1901 if ((this->getModel()).isModelLinearized()) {
1902 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH4lRatio()));
1903 } else {
1904 return myNPbase->muWHZZ4l(sqrt_s);
1905 }
1906}
1907
1908muVHZZ4l::muVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
1909: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1910{
1911 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1912 throw std::runtime_error("muVHZZ4l called with a class whose parent is not NPbase");
1913}
1914
1916{
1917 if ((this->getModel()).isModelLinearized()) {
1918 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH4lRatio()));
1919 } else {
1920 return myNPbase->muVHZZ4l(sqrt_s);
1921 }
1922}
1923
1924muttHZZ4l::muttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
1925: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1926{
1927 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1928 throw std::runtime_error("muttHZZ4l called with a class whose parent is not NPbase");
1929}
1930
1932{
1933 if ((this->getModel()).isModelLinearized()) {
1934 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH4lRatio()));
1935 } else {
1936 return myNPbase->muttHZZ4l(sqrt_s);
1937 }
1938}
1939
1940muggHWW::muggHWW(const StandardModel& SM_i, const double sqrt_s_i)
1941: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1942{
1943 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1944 throw std::runtime_error("muggHWW called with a class whose parent is not NPbase");
1945}
1946
1948{
1949 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1950 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHWWRatio()));
1951 //AG: Most general expression including quadratic corrections.
1952 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1953 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1954 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1955 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
1956 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
1957
1958 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1959 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1960 double Br1 = dGammaR1-dGammaRTot1;
1961 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1962 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1963 } else {
1964 return myNPbase->muggHWW(sqrt_s);
1965 }
1966}
1967
1968muVBFHWW::muVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
1969: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1970{
1971 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1972 throw std::runtime_error("muVBFHWW called with a class whose parent is not NPbase");
1973}
1974
1976{
1977 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1978 //AG: Most general expression including quadratic corrections.
1979 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1980 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHWWRatio()));
1981 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1982 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1983 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
1984 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
1985
1986 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1987 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1988 double Br1 = dGammaR1-dGammaRTot1;
1989 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1990 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1991 } else {
1992 return myNPbase->muVBFHWW(sqrt_s);
1993 }
1994}
1995
1996muZHWW::muZHWW(const StandardModel& SM_i, const double sqrt_s_i)
1997: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1998{
1999 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2000 throw std::runtime_error("muZHWW called with a class whose parent is not NPbase");
2001}
2002
2004{
2005 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2006 //AG: Most general expression including quadratic corrections.
2007 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2008 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2009 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2010 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2011 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2012 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2013
2014 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2015 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2016 double Br1 = dGammaR1-dGammaRTot1;
2017 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2018 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2019 } else {
2020 return myNPbase->muZHWW(sqrt_s);
2021 }
2022}
2023
2024muWHWW::muWHWW(const StandardModel& SM_i, const double sqrt_s_i)
2025: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2026{
2027 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2028 throw std::runtime_error("muWHWW called with a class whose parent is not NPbase");
2029}
2030
2032{
2033 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2034 //AG: Most general expression including quadratic corrections.
2035 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2036 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2037 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2038 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2039 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2040 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2041
2042 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2043 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2044 double Br1 = dGammaR1-dGammaRTot1;
2045 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2046 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2047 } else {
2048 return myNPbase->muWHWW(sqrt_s);
2049 }
2050}
2051
2052muVHWW::muVHWW(const StandardModel& SM_i, const double sqrt_s_i)
2053: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2054{
2055 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2056 throw std::runtime_error("muVHWW called with a class whose parent is not NPbase");
2057}
2058
2060{
2061 if ((this->getModel()).isModelLinearized()) {
2062 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2063 } else {
2064 return myNPbase->muVHWW(sqrt_s);
2065 }
2066}
2067
2068muttHWW::muttHWW(const StandardModel& SM_i, const double sqrt_s_i)
2069: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2070{
2071 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2072 throw std::runtime_error("muttHWW called with a class whose parent is not NPbase");
2073}
2074
2076{
2077 if ((this->getModel()).isModelLinearized()) {
2078 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2079 } else {
2080 return myNPbase->muttHWW(sqrt_s);
2081 }
2082}
2083
2084muttHptH_HWW::muttHptH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2085: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2086{
2087 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2088 throw std::runtime_error("muttHptH_HWW called with a class whose parent is not NPbase");
2089}
2090
2092{
2093
2094 //VM:Note that these values are valid for 13 TeV, they are not general
2095 //We should access the SM function that has all the values (for the
2096 //different energies). The values are slightly different, we should
2097 //check this.
2098 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2099 double xsSM_ttH = 0.499873;
2100 double xsSM_tH = 0.0821;
2101 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2102 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2103 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2104 //AG: Most general expression including quadratic corrections.
2105 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2106 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2107 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2108 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2109 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2110
2111 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2112 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2113 double Br1 = dGammaR1-dGammaRTot1;
2114 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2115 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2116 } else {
2117
2118 //VM: Just in case someone wants to add directly the production*decay
2119 //(which is the observable we fit at the end)
2120 double NPmuttHptH_HWW = myNPbase->muttHptH_HWW(sqrt_s);
2121 if(NPmuttHptH_HWW==1.0){
2122 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHWWRatio()) ;
2123 } else {
2124 return NPmuttHptH_HWW;
2125 }
2126 }
2127}
2128
2129muggHpbbH_HWW::muggHpbbH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2130: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2131{
2132 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2133 throw std::runtime_error("muggHpbbH_HWW called with a class whose parent is not NPbase");
2134}
2135
2137{
2138 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2139 //AG: Most general expression including quadratic corrections.
2140 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2141 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.));
2142 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2143 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2144 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2145 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2146
2147 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2148 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2149 double Br1 = dGammaR1-dGammaRTot1;
2150 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2151 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2152 } else {
2153
2154 //VM: Just in case someone wants to add directly the production*decay
2155 //(which is the observable we fit at the end)
2156 //Also, the bbH is missing here, I'll leave it as it was for the
2157 //moment (since bbH is really suppressed in the SM).
2158 double NPmuggHpbbH_HWW = myNPbase->muggHpbbH_HWW(sqrt_s);
2159 if (NPmuggHpbbH_HWW == 1.0){
2160 return (myNPbase->muggHWW(sqrt_s));
2161 } else{
2162 return NPmuggHpbbH_HWW;
2163 }
2164 }
2165}
2166
2167muggHWW2l2v::muggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2168: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2169{
2170 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2171 throw std::runtime_error("muggHWW2l2v called with a class whose parent is not NPbase");
2172}
2173
2175{
2176 if ((this->getModel()).isModelLinearized()) {
2177 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2178 } else {
2179 return myNPbase->muggHWW2l2v(sqrt_s);
2180 }
2181}
2182
2183muVBFHWW2l2v::muVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2184: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2185{
2186 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2187 throw std::runtime_error("muVBFHWW2l2v called with a class whose parent is not NPbase");
2188}
2189
2191{
2192 if ((this->getModel()).isModelLinearized()) {
2193 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2194 } else {
2195 return myNPbase->muVBFHWW2l2v(sqrt_s);
2196 }
2197}
2198
2199muZHWW2l2v::muZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2200: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2201{
2202 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2203 throw std::runtime_error("muZHWW2l2v called with a class whose parent is not NPbase");
2204}
2205
2207{
2208 if ((this->getModel()).isModelLinearized()) {
2209 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2210 } else {
2211 return myNPbase->muZHWW2l2v(sqrt_s);
2212 }
2213}
2214
2215muWHWW2l2v::muWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2216: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2217{
2218 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2219 throw std::runtime_error("muWHWW2l2v called with a class whose parent is not NPbase");
2220}
2221
2223{
2224 if ((this->getModel()).isModelLinearized()) {
2225 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2226 } else {
2227 return myNPbase->muWHWW2l2v(sqrt_s);
2228 }
2229}
2230
2231muVHWW2l2v::muVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2232: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2233{
2234 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2235 throw std::runtime_error("muVHWW2l2v called with a class whose parent is not NPbase");
2236}
2237
2239{
2240 if ((this->getModel()).isModelLinearized()) {
2241 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2242 } else {
2243 return myNPbase->muVHWW2l2v(sqrt_s);
2244 }
2245}
2246
2247muttHWW2l2v::muttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2248: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2249{
2250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2251 throw std::runtime_error("muttHWW2l2v called with a class whose parent is not NPbase");
2252}
2253
2255{
2256 if ((this->getModel()).isModelLinearized()) {
2257 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2258 } else {
2259 return myNPbase->muttHWW2l2v(sqrt_s);
2260 }
2261}
2262
2263muttHVV::muttHVV(const StandardModel& SM_i, const double sqrt_s_i)
2264: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2265{
2266 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2267 throw std::runtime_error("muttHVV called with a class whose parent is not NPbase");
2268}
2269
2271{
2272 if ((this->getModel()).isModelLinearized()) {
2273 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHVVRatio()));
2274 } else {
2275 return (myNPbase->muttH(sqrt_s)) * (myNPbase->BrHVVRatio());
2276 }
2277}
2278
2279muggHmumu::muggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2280: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2281{
2282 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2283 throw std::runtime_error("muggHmumu called with a class whose parent is not NPbase");
2284}
2285
2287{
2288 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2289 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2290 //AG: Most general expression including quadratic corrections.
2291 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2292 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2293 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2294 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2295 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2296
2297 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2298 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2299 double Br1 = dGammaR1-dGammaRTot1;
2300 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2301 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2302 } else {
2303 return myNPbase->muggHmumu(sqrt_s);
2304 }
2305}
2306
2307muVBFHmumu::muVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2308: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2309{
2310 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2311 throw std::runtime_error("muVBFHmumu called with a class whose parent is not NPbase");
2312}
2313
2315{
2316 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2317 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2318 //AG: Most general expression including quadratic corrections.
2319 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2320 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2321 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2322 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2323 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2324
2325 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2326 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2327 double Br1 = dGammaR1-dGammaRTot1;
2328 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2329 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2330 } else {
2331 return myNPbase->muVBFHmumu(sqrt_s);
2332 }
2333}
2334
2335muZHmumu::muZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2336: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2337{
2338 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2339 throw std::runtime_error("muZHmumu called with a class whose parent is not NPbase");
2340}
2341
2343{
2344 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2345 //AG: Most general expression including quadratic corrections.
2346 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2347 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2348 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2349 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2350 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2351
2352 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2353 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2354 double Br1 = dGammaR1-dGammaRTot1;
2355 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2356 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2357 } else {
2358 return myNPbase->muZHmumu(sqrt_s);
2359 }
2360}
2361
2362muWHmumu::muWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2363: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2364{
2365 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2366 throw std::runtime_error("muWHmumu called with a class whose parent is not NPbase");
2367}
2368
2370{
2371 if ((this->getModel()).isModelLinearized()) {
2372 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2373 } else {
2374 return myNPbase->muWHmumu(sqrt_s);
2375 }
2376}
2377
2378muVHmumu::muVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2379: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2380{
2381 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2382 throw std::runtime_error("muVHmumu called with a class whose parent is not NPbase");
2383}
2384
2386{
2387
2388 //VM:Note that these values are valid for 13 TeV, they are not general
2389 //We should access the SM function that has all the values (for the
2390 //different energies). The values are slightly different, we should
2391 //check this.
2392 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2393 double xsSM_WH = 1.21539;
2394 double xsSM_ZH = 0.795910;
2395 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2396 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2397 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2398 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2399 //AG: Most general expression including quadratic corrections.
2400 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2401 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2402 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2403 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2404 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2405
2406 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2407 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2408 double Br1 = dGammaR1-dGammaRTot1;
2409 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2410 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2411 } else {
2412 //return myNPbase->muVHmumu(sqrt_s);
2413 //VM: Just in case someone wants to add directly the production*decay
2414 //(which is the observable we fit at the end)
2415 double NPmuVHmumu = myNPbase->muVHmumu(sqrt_s);
2416 if(NPmuVHmumu==1.0){
2417 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHmumuRatio());
2418 } else {
2419 return NPmuVHmumu;
2420 }
2421
2422 }
2423}
2424
2425muttHmumu::muttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2426: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2427{
2428 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2429 throw std::runtime_error("muttHmumu called with a class whose parent is not NPbase");
2430}
2431
2433{
2434 if ((this->getModel()).isModelLinearized()) {
2435 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2436 } else {
2437 return myNPbase->muttHmumu(sqrt_s);
2438 }
2439}
2440
2441muggHpttHptHpbbH_Hmumu::muggHpttHptHpbbH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2442: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2443{
2444 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2445 throw std::runtime_error("muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2446}
2447
2449{
2450 //VM:Note that these values are valid for 13 TeV, they are not general
2451 //We should access the SM function that has all the values (for the
2452 //different energies). The values are slightly different, we should
2453 //check this. Furthermore, the bbH is not included. In the SM this is
2454 //very suppressed (and it's probably also the case in the SMEFT) but
2455 //in some NP models it may not be the case.Unfortunately, bbH is not
2456 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
2457 //SMEFT and add here the general expression.
2458 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2459 double xsSM_ggHbbH = 44.745;
2460 double xsSM_ttH = 0.4998;
2461 double xsSM_tH = 0.084769;
2462 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
2463 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2464 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
2465 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
2466
2467
2468
2469 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2470 //AG: Most general expression including quadratic corrections.
2471 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2472 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2473 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2474 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2475 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2476
2477 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2478 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2479 double Br1 = dGammaR1-dGammaRTot1;
2480 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2481 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2482 } else {
2483
2484 //VM: Just in case someone wants to add directly the production*decay
2485 //(which is the observable we fit at the end). Furthermore, the Hbb
2486 //is not added in the original formula, fine for the SM (probably also
2487 //for the SMEFT) but not for all NP models.
2488 double NPmuggHpttHptHpbbH_Hmumu = myNPbase->muggHpttHptHpbbH_Hmumu(sqrt_s);
2489 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2490 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHmumuRatio()) ;
2491 } else {
2492 return NPmuggHpttHptHpbbH_Hmumu;
2493 }
2494 }
2495}
2496
2497muVBFpVH_Hmumu::muVBFpVH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2498: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2499{
2500 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2501 throw std::runtime_error("muVBFpVH_Hmumu called with a class whose parent is not NPbase");
2502}
2503
2505{
2506
2507 //VM:Note that these values are valid for 13 TeV, they are not general
2508 //We should access the SM function that has all the values (for the
2509 //different energies). The values are slightly different, we should
2510 //check this.
2511 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2512 double xsSM_VBF = 3.49948;
2513 double xsSM_WH = 1.21539;
2514 double xsSM_ZH = 0.795910;
2515 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
2516 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2517 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2518 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2519 //AG: Most general expression including quadratic corrections.
2520 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2521 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2522 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2523 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2524 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2525
2526 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2527 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2528 double Br1 = dGammaR1-dGammaRTot1;
2529 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2530 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2531 } else {
2532
2533 //VM: Just in case someone wants to add directly the production*decay
2534 //(which is the observable we fit at the end).
2535 double NPmuVBFpVH_Hmumu = myNPbase->muVBFpVH_Hmumu(sqrt_s);
2536 if(NPmuVBFpVH_Hmumu==1.0){
2537 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHmumuRatio()) ;
2538 } else {
2539 return NPmuVBFpVH_Hmumu;
2540 }
2541 }
2542}
2543
2544muggHtautau::muggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2545: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2546{
2547 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2548 throw std::runtime_error("muggHtautau called with a class whose parent is not NPbase");
2549}
2550
2552{
2553 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2554 //AG: Most general expression including quadratic corrections.
2555 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2556 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2557 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2558 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2559 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2560 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2561
2562 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2563 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2564 double Br1 = dGammaR1-dGammaRTot1;
2565 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2566 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2567 } else {
2568 return myNPbase->muggHtautau(sqrt_s);
2569 }
2570}
2571
2572muVBFHtautau::muVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2573: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2574{
2575 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2576 throw std::runtime_error("muVBFHtautau called with a class whose parent is not NPbase");
2577}
2578
2580{
2581 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2582 //AG: Most general expression including quadratic corrections.
2583 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2584 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2585 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2586 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2587 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2588 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2589
2590 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2591 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2592 double Br1 = dGammaR1-dGammaRTot1;
2593 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2594 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2595 } else {
2596 return myNPbase->muVBFHtautau(sqrt_s);
2597 }
2598}
2599
2600
2601
2602muVBFpVHtautau::muVBFpVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2603: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2604{
2605 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2606 throw std::runtime_error("muVBFpVHtautau called with a class whose parent is not NPbase");
2607}
2608
2610{
2611 if ((this->getModel()).isModelLinearized()) {
2612 return ( -1.0 + (myNPbase->muVBFpVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2613 } else {
2615 }
2616}
2617
2618
2619muZHtautau::muZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2620: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2621{
2622 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2623 throw std::runtime_error("muZHtautau called with a class whose parent is not NPbase");
2624}
2625
2626double muZHtautau::computeThValue() //AG:modified
2627{
2628 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2629 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2630 //AG: Most general expression including quadratic corrections.
2631 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2632 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2633 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2634 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2635 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2636 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2637
2638 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2639 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2640 double Br1 = dGammaR1-dGammaRTot1;
2641 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2642 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2643 } else {
2644 return myNPbase->muZHtautau(sqrt_s);
2645 }
2646}
2647
2648muWHtautau::muWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2649: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2650{
2651 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2652 throw std::runtime_error("muWHtautau called with a class whose parent is not NPbase");
2653}
2654
2656{
2657 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2658 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2659 //AG: Most general expression including quadratic corrections.
2660 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2661 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2662 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2663 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2664 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2665
2666 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2667 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2668 double Br1 = dGammaR1-dGammaRTot1;
2669 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2670
2671 /*std::cout << "muProd1="<<muProd1<<std::endl;
2672 std::cout << "muProd2="<<muProd2<<std::endl;
2673 std::cout << "dGammaR1="<<dGammaR1<<std::endl;
2674 std::cout << "dGammaR2="<<dGammaR2<<std::endl;
2675 std::cout << "dGammaRTot1="<<dGammaRTot1<<std::endl;
2676 std::cout << "dGammaRTot2="<<dGammaRTot2<<std::endl;
2677
2678 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;
2679 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;*/
2680
2681 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2682
2683 } else {
2684 return myNPbase->muWHtautau(sqrt_s);
2685 }
2686}
2687
2688muVHtautau::muVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2689: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2690{
2691 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2692 throw std::runtime_error("muVHtautau called with a class whose parent is not NPbase");
2693}
2694
2696{
2697 //VM:Note that these values are valid for 13 TeV, they are not general
2698 //We should access the SM function that has all the values (for the
2699 //different energies). The values are slightly different, we should
2700 //check this.
2701 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2702 double xsSM_WH = 1.21539;
2703 double xsSM_ZH = 0.795910;
2704 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2705 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2706 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2707 //AG: Most general expression including quadratic corrections.
2708 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2709 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2710 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2711 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2712 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2713 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2714
2715 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2716 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2717 double Br1 = dGammaR1-dGammaRTot1;
2718 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2719 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2720 } else {
2721 //return myNPbase->muVHtautau(sqrt_s);
2722
2723 //VM: Just in case someone wants to add directly the production*decay
2724 //(which is the observable we fit at the end)
2725 double NPmuVHtautau = myNPbase->muVHtautau(sqrt_s);
2726 if(NPmuVHtautau==1.0){
2727 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHtautauRatio());
2728 } else {
2729 return NPmuVHtautau;
2730 }
2731 }
2732}
2733
2734muttHtautau::muttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2735: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2736{
2737 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2738 throw std::runtime_error("muttHtautau called with a class whose parent is not NPbase");
2739}
2740
2742{
2743 if ((this->getModel()).isModelLinearized()) {
2744 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2745 } else {
2746 return myNPbase->muttHtautau(sqrt_s);
2747 }
2748}
2749
2750muttHptH_Htautau::muttHptH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2751: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2752{
2753 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2754 throw std::runtime_error("muttHptH_Htautau called with a class whose parent is not NPbase");
2755}
2756
2758{
2759 //VM:Note that these values are valid for 13 TeV, they are not general
2760 //We should access the SM function that has all the values (for the
2761 //different energies). The values are slightly different, we should
2762 //check this.
2763 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2764 double xsSM_ttH = 0.499873;
2765 double xsSM_tH = 0.0821;
2766 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2767 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2768 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2769 //AG: Most general expression including quadratic corrections.
2770 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2771 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2772 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2773 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2774 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2775
2776 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2777 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2778 double Br1 = dGammaR1-dGammaRTot1;
2779 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2780 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2781 } else {
2782
2783 //VM: Just in case someone wants to add directly the production*decay
2784 //(which is the observable we fit at the end)
2785 double NPmuttHptH_Htautau = myNPbase->muttHptH_Htautau(sqrt_s);
2786 if(NPmuttHptH_Htautau==1.0){
2787 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHtautauRatio()) ;
2788 } else {
2789 return NPmuttHptH_Htautau;
2790 }
2791
2792 }
2793}
2794
2795muggHpbbH_Htautau::muggHpbbH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2796: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2797{
2798 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2799 throw std::runtime_error("muggHpbbH_Htautau called with a class whose parent is not NPbase");
2800}
2801
2803{
2804 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2805 //AG: Most general expression including quadratic corrections.
2806 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2807 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.));
2808 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2809 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2810 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2811 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2812
2813 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2814 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2815 double Br1 = dGammaR1-dGammaRTot1;
2816 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2817 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2818 } else {
2819
2820 //VM: Just in case someone wants to add directly the production*decay
2821 //(which is the observable we fit at the end)
2822 //Also, the bbH is missing here, I'll leave it as it was for the
2823 //moment (since bbH is really suppressed in the SM).
2824 double NPmuggHpbbH_Htautau = myNPbase->muggHpbbH_Htautau(sqrt_s);
2825 if (NPmuggHpbbH_Htautau == 1.0){
2826 return (myNPbase->muggHtautau(sqrt_s));
2827 } else{
2828 return NPmuggHpbbH_Htautau;
2829 }
2830 }
2831}
2832
2833muggHbb::muggHbb(const StandardModel& SM_i, const double sqrt_s_i)
2834: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2835{
2836 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2837 throw std::runtime_error("muggHbb called with a class whose parent is not NPbase");
2838}
2839
2841{
2842 if ((this->getModel()).isModelLinearized()) {
2843 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHbbRatio()));
2844 //AG: Most general expression including quadratic corrections.
2845 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2846 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2847 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2848 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
2849 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
2850
2851 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2852 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2853 double Br1 = dGammaR1-dGammaRTot1;
2854 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2855 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2856 } else {
2857 return myNPbase->muggHbb(sqrt_s);
2858 }
2859}
2860
2861muVBFHbb::muVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
2862: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2863{
2864 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2865 throw std::runtime_error("muVBFHbb called with a class whose parent is not NPbase");
2866}
2867
2869{
2870 if ((this->getModel()).isModelLinearized()) {
2871 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHbbRatio()));
2872 } else {
2873 return myNPbase->muVBFHbb(sqrt_s);
2874 }
2875}
2876
2877muZHbb::muZHbb(const StandardModel& SM_i, const double sqrt_s_i)
2878: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2879{
2880 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2881 throw std::runtime_error("muZHbb called with a class whose parent is not NPbase");
2882}
2883
2885{
2886 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2887 //AG: Most general expression including quadratic corrections.
2888 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2889 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHbbRatio()));
2890 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2891 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2892 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
2893 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
2894
2895 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2896 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2897 double Br1 = dGammaR1-dGammaRTot1;
2898 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2899 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2900 } else {
2901 return myNPbase->muZHbb(sqrt_s);
2902 }
2903}
2904
2905muWHbb::muWHbb(const StandardModel& SM_i, const double sqrt_s_i)
2906: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2907{
2908 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2909 throw std::runtime_error("muWHbb called with a class whose parent is not NPbase");
2910}
2911
2913{
2914 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2915 //AG: Most general expression including quadratic corrections.
2916 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2917 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHbbRatio()));
2918 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2919 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2920 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
2921 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
2922
2923 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2924 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2925 double Br1 = dGammaR1-dGammaRTot1;
2926 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2927 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2928 } else {
2929 return myNPbase->muWHbb(sqrt_s);
2930 }
2931}
2932
2933muVHbb::muVHbb(const StandardModel& SM_i, const double sqrt_s_i)
2934: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2935{
2936 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2937 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
2938}
2939
2941{
2942 if ((this->getModel()).isModelLinearized()) {
2943 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHbbRatio()));
2944 } else {
2945 return myNPbase->muVHbb(sqrt_s);
2946 }
2947}
2948
2949muttHbb::muttHbb(const StandardModel& SM_i, const double sqrt_s_i)
2950: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2951{
2952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2953 throw std::runtime_error("muttHbb called with a class whose parent is not NPbase");
2954}
2955
2957{
2958 if ((this->getModel()).isModelLinearized()) {
2959 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHbbRatio()));
2960 } else {
2961 return myNPbase->muttHbb(sqrt_s);
2962 }
2963}
2964
2965muttHptH_Hbb::muttHptH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2966: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2967{
2968 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2969 throw std::runtime_error("muttHptH_Hbb called with a class whose parent is not NPbase");
2970}
2971
2973{
2974 //VM:Note that these values are valid for 13 TeV, they are not general
2975 //We should access the SM function that has all the values (for the
2976 //different energies). The values are slightly different, we should
2977 //check this.
2978 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2979 double xsSM_ttH = 0.499873;
2980 double xsSM_tH = 0.0821;
2981 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2982 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2983 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2984 //AG: Most general expression including quadratic corrections.
2985 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2986 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2987 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2988 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
2989 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
2990
2991 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2992 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2993 double Br1 = dGammaR1-dGammaRTot1;
2994 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2995 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
2996 } else {
2997
2998
2999 //VM: Just in case someone wants to add directly the production*decay
3000 //(which is the observable we fit at the end)
3001 double NPmuttHptH_Hbb = myNPbase->muttHptH_Hbb(sqrt_s);
3002 if(NPmuttHptH_Hbb==1.0){
3003 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHbbRatio()) ;
3004 } else {
3005 return NPmuttHptH_Hbb;
3006 }
3007 }
3008}
3009
3010muggHpVBFpbbH_Hbb::muggHpVBFpbbH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3011: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3012{
3013 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3014 throw std::runtime_error("muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3015}
3016
3018{
3019 //VM:Note that these values are valid for 13 TeV, they are not general
3020 //We should access the SM function that has all the values (for the
3021 //different energies). The values are slightly different, we should
3022 //check this. Furthermore, the bbH is not included. In the SM this is
3023 //very suppressed (and it's probably also the case in the SMEFT) but
3024 //in some NP models it may not be the case.Unfortunately, bbH is not
3025 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
3026 //SMEFT and add here the general expression.
3027 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3028 double xsSM_ggHbbH = 44.745;
3029 double xsSM_VBF = 3.49948;
3030 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
3031 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3032 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
3033 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3034 //AG: Most general expression including quadratic corrections.
3035 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3036 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3037 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3038 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3039 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3040
3041 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3042 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3043 double Br1 = dGammaR1-dGammaRTot1;
3044 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3045 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
3046 } else {
3047
3048
3049 //VM: Just in case someone wants to add directly the production*decay
3050 //(which is the observable we fit at the end). Furthermore, the Hbb
3051 //is not added in the original formula, fine for the SM (probably also
3052 //for the SMEFT) but not for all NP models.
3053 double NPmuggHpVBFpbbH_Hbb = myNPbase->muggHpVBFpbbH_Hbb(sqrt_s);
3054 if(NPmuggHpVBFpbbH_Hbb==1.0){
3055 return ( xsSM_ggHbbH*(myNPbase->muggH(sqrt_s)) + xsSM_VBF*(myNPbase->muVBF(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF) * (myNPbase->BrHbbRatio()) ;
3056 } else {
3057 return NPmuggHpVBFpbbH_Hbb;
3058 }
3059 }
3060}
3061
3062
3063
3064muVHcc::muVHcc(const StandardModel& SM_i, const double sqrt_s_i)
3065: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3066{
3067 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3068 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3069}
3070
3072{
3073 if ((this->getModel()).isModelLinearized()) {
3074 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHccRatio()));
3075 } else {
3076 return myNPbase->muVHcc(sqrt_s);
3077 }
3078}
3079
3080
3081muVBFBRinv::muVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3082: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3083{
3084 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3085 throw std::runtime_error("muVBFBRinv called with a class whose parent is not NPbase");
3086}
3087
3089{
3090
3091 return (myNPbase->muVBF(sqrt_s))*(myNPbase->Br_H_inv());
3092
3093}
3094
3095muVBFHinv::muVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
3096: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3097{
3098 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3099 throw std::runtime_error("muVBFHinv called with a class whose parent is not NPbase");
3100}
3101
3103{
3104
3105 if ((this->getModel()).isModelLinearized()) {
3106 return ((myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3107 } else {
3108 return (myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtoinvRatio());
3109 }
3110
3111}
3112
3113
3114muVHBRinv::muVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3115: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3116{
3117 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3118 throw std::runtime_error("muVHBRinv called with a class whose parent is not NPbase");
3119}
3120
3122{
3123
3124 return (myNPbase->muVH(sqrt_s))*(myNPbase->Br_H_inv());
3125
3126}
3127
3128muVHinv::muVHinv(const StandardModel& SM_i, const double sqrt_s_i)
3129: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3130{
3131 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3132 throw std::runtime_error("muVHinv called with a class whose parent is not NPbase");
3133}
3134
3136{
3137
3138 if ((this->getModel()).isModelLinearized()) {
3139 return ((myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3140 } else {
3141 return (myNPbase->muVH(sqrt_s))*(myNPbase->BrHtoinvRatio());
3142 }
3143
3144}
3145
3146
3147muppHmumu::muppHmumu(const StandardModel& SM_i, const double sqrt_s_i)
3148: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3149{
3150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3151 throw std::runtime_error("muppHmumu called with a class whose parent is not NPbase");
3152}
3153
3155{
3156 return myNPbase->muppHmumu(sqrt_s);
3157}
3158
3159muppHZga::muppHZga(const StandardModel& SM_i, const double sqrt_s_i)
3160: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3161{
3162 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3163 throw std::runtime_error("muppHZga called with a class whose parent is not NPbase");
3164}
3165
3167{
3168 return myNPbase->muppHZga(sqrt_s);
3169}
3170
3171muggHH2ga2b::muggHH2ga2b(const StandardModel& SM_i, const double sqrt_s_i)
3172: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3173{
3174 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3175 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
3176}
3177
3179{
3180 if ((this->getModel()).isModelLinearized()) {
3181 return (-2.0 + (myNPbase->muggHH(sqrt_s)) + (myNPbase->BrHgagaRatio()) + (myNPbase->BrHbbRatio()));
3182 } else {
3184 }
3185}
3186
3187muttHZbbboost::muttHZbbboost(const StandardModel& SM_i, const double sqrt_s_i)
3188: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3189{
3190 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3191 throw std::runtime_error("muttHZbbboost called with a class whose parent is not NPbase");
3192}
3193
3195{
3196 return (myNPbase->muttHZbbboost(sqrt_s));
3197}
3198
3199//AG:begin
3200ggHgaga::ggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3201: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3202{
3203 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3204 throw std::runtime_error("ggHgaga called with a class whose parent is not NPbase");
3205}
3207{
3208 double SM_prediction = 0.0439; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3209 if ((this->getModel()).isModelLinearized()) {
3210 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3211 } else {
3212 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHgagaRatio());
3213 }
3214}
3215
3216
3217ggHZZ::ggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3218: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3219{
3220 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3221 throw std::runtime_error("ggHZZ called with a class whose parent is not NPbase");
3222}
3224{
3225 double SM_prediction = 0.5197; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3226 if ((this->getModel()).isModelLinearized()) {
3227 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3228 } else {
3229 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHZZRatio());
3230 }
3231}
3232
3233
3234ggHWW::ggHWW(const StandardModel& SM_i, const double sqrt_s_i)
3235: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3236{
3237 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3238 throw std::runtime_error("ggHWW called with a class whose parent is not NPbase");
3239}
3241{
3242 double SM_prediction = 4.1603; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3243 if ((this->getModel()).isModelLinearized()) {
3244 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3245 } else {
3246 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHWWRatio());
3247 }
3248}
3249
3250
3251ggHtautau::ggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3252: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3253{
3254 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3255 throw std::runtime_error("ggHtautau called with a class whose parent is not NPbase");
3256}
3258{
3259 double SM_prediction = 1.2215; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3260 if ((this->getModel()).isModelLinearized()) {
3261 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3262 } else {
3263 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHtautauRatio());
3264 }
3265}
3266
3267
3268VBFHgaga::VBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3269: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3270{
3271 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3272 throw std::runtime_error("VBFHgaga called with a class whose parent is not NPbase");
3273}
3275{
3276 double SM_prediction = 0.0037; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3277 if ((this->getModel()).isModelLinearized()) {
3278 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3279 } else {
3280 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHgagaRatio());
3281 }
3282}
3283
3284
3285VBFHZZ::VBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3286: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3287{
3288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3289 throw std::runtime_error("VBFHZZ called with a class whose parent is not NPbase");
3290}
3292{
3293 double SM_prediction = 0.0530; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3294 if ((this->getModel()).isModelLinearized()) {
3295 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3296 } else {
3297 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHZZRatio());
3298 }
3299}
3300
3301
3302VBFHWW::VBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
3303: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3304{
3305 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3306 throw std::runtime_error("VBFHWW called with a class whose parent is not NPbase");
3307}
3309{
3310 double SM_prediction = 0.3494; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3311 if ((this->getModel()).isModelLinearized()) {
3312 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3313 } else {
3314 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHWWRatio());
3315 }
3316}
3317
3318
3319VBFHtautau::VBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3320: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3321{
3322 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3323 throw std::runtime_error("VBFHtautau called with a class whose parent is not NPbase");
3324}
3326{
3327 double SM_prediction = 0.1011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3328 if ((this->getModel()).isModelLinearized()) {
3329 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3330 } else {
3331 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtautauRatio());
3332 }
3333}
3334
3335
3336WHgaga::WHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3337: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3338{
3339 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3340 throw std::runtime_error("WHgaga called with a class whose parent is not NPbase");
3341}
3343{
3344 double SM_prediction = 0.0017; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3345 if ((this->getModel()).isModelLinearized()) {
3346 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3347 } else {
3348 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHgagaRatio());
3349 }
3350}
3351
3352
3353WHWW::WHWW(const StandardModel& SM_i, const double sqrt_s_i)
3354: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3355{
3356 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3357 throw std::runtime_error("WHWW called with a class whose parent is not NPbase");
3358}
3360{
3361 double SM_prediction = 0.1614; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3362 if ((this->getModel()).isModelLinearized()) {
3363 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3364 } else {
3365 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHWWRatio());
3366 }
3367}
3368
3369
3370WHtautau::WHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3372{
3373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3374 throw std::runtime_error("WWHtautau called with a class whose parent is not NPbase");
3375}
3377{
3378 double SM_prediction = 0.0462; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3379 if ((this->getModel()).isModelLinearized()) {
3380 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3381 } else {
3382 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHtautauRatio());
3383 }
3384}
3385
3386
3387WHbb::WHbb(const StandardModel& SM_i, const double sqrt_s_i)
3388: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3389{
3390 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3391 throw std::runtime_error("WHbb called with a class whose parent is not NPbase");
3392}
3394{
3395 double SM_prediction = 0.4090; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3396 if ((this->getModel()).isModelLinearized()) {
3397 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3398 } else {
3399 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHbbRatio());
3400 }
3401}
3402
3403
3404ZHgaga::ZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3405: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3406{
3407 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3408 throw std::runtime_error("ZHgaga called with a class whose parent is not NPbase");
3409}
3411{
3412 double SM_prediction = 0.0011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3413 if ((this->getModel()).isModelLinearized()) {
3414 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3415 } else {
3416 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHgagaRatio());
3417 }
3418}
3419
3420
3421ZHWW::ZHWW(const StandardModel& SM_i, const double sqrt_s_i)
3422: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3423{
3424 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3425 throw std::runtime_error("ZHWW called with a class whose parent is not NPbase");
3426}
3428{
3429 double SM_prediction = 0.0996; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3430 if ((this->getModel()).isModelLinearized()) {
3431 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3432 } else {
3433 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHWWRatio());
3434 }
3435}
3436
3437
3438ZHtautau::ZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3439: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3440{
3441 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3442 throw std::runtime_error("ZHtautau called with a class whose parent is not NPbase");
3443}
3445{
3446 double SM_prediction = 0.0304; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3447 if ((this->getModel()).isModelLinearized()) {
3448 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3449 } else {
3450 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHtautauRatio());
3451 }
3452}
3453
3454
3455ZHbb::ZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3456: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3457{
3458 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3459 throw std::runtime_error("ZHbb called with a class whose parent is not NPbase");
3460}
3462{
3463 double SM_prediction = 0.2410; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3464 if ((this->getModel()).isModelLinearized()) {
3465 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3466 } else {
3467 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHbbRatio());
3468 }
3469}
3470
3471
3472ttHgaga::ttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3473: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3474{
3475 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3476 throw std::runtime_error("ttHgaga called with a class whose parent is not NPbase");
3477}
3479{
3480 double SM_prediction = 0.0004; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3481 if ((this->getModel()).isModelLinearized()) {
3482 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3483 } else {
3484 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHgagaRatio());
3485 }
3486}
3487
3488
3489ttHWW::ttHWW(const StandardModel& SM_i, const double sqrt_s_i)
3490: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3491{
3492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3493 throw std::runtime_error("ttHWW called with a class whose parent is not NPbase");
3494}
3496{
3497 double SM_prediction = 0.0281; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3498 if ((this->getModel()).isModelLinearized()) {
3499 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3500 } else {
3501 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHWWRatio());
3502 }
3503}
3504
3505
3506ttHtautau::ttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3507: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3508{
3509 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3510 throw std::runtime_error("ttHtautau called with a class whose parent is not NPbase");
3511}
3513{
3514 double SM_prediction = 0.0106; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3515 if ((this->getModel()).isModelLinearized()) {
3516 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3517 } else {
3518 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHtautauRatio());
3519 }
3520}
3521
3522
3523ttHbb::ttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3524: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3525{
3526 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3527 throw std::runtime_error("ttHbb called with a class whose parent is not NPbase");
3528}
3530{
3531 double SM_prediction = 0.0751; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3532 if ((this->getModel()).isModelLinearized()) {
3533 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3534 } else {
3535 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHbbRatio());
3536 }
3537}
3538
3539//AG:end
3540
3541UpperLimit_ppHZgammaA::UpperLimit_ppHZgammaA(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3542{
3543 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3544 throw std::runtime_error("UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
3545}
3546
3548{
3550}
3551
3552UpperLimit_ppHZgammaA13::UpperLimit_ppHZgammaA13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3553{
3554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3555 throw std::runtime_error("UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
3556}
3557
3559{
3561}
3562
3563UpperLimit_ppHZgammaC13::UpperLimit_ppHZgammaC13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3564{
3565 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3566 throw std::runtime_error("UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
3567}
3568
3570{
3572}
3573
3574UpperLimit_ppHZgammaC::UpperLimit_ppHZgammaC(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3575{
3576 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3577 throw std::runtime_error("UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
3578}
3579
3581{
3583}
3584
3586{
3587 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3588 throw std::runtime_error("cg_plus_ct called with a class whose parent is not NPbase");
3589}
3590
3592{
3593 return myNPbase->cgplusct();
3594}
3595
3597{
3598 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3599 throw std::runtime_error("cga_plus_ct called with a class whose parent is not NPbase");
3600}
3601
3603{
3604 return myNPbase->cgaplusct();
3605}
3606
3608{
3609 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3610 throw std::runtime_error("cg_minus_cga called with a class whose parent is not NPbase");
3611}
3612
3614{
3615 return myNPbase->cgminuscga();
3616}
3617
3619{
3620 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3621 throw std::runtime_error("cV_plus_cb called with a class whose parent is not NPbase");
3622}
3623\
3624
3625
3627{
3628 return myNPbase->cVpluscb();
3629}
3630
3632{
3633 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3634 throw std::runtime_error("cV_plus_ctau called with a class whose parent is not NPbase");
3635}
3636
3638{
3639 return myNPbase->cVplusctau();
3640}
3641
3643{
3644 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3645 throw std::runtime_error("cb_minus_cc called with a class whose parent is not NPbase");
3646}
3647
3649{
3650 return myNPbase->cbminuscc();
3651}
3652
3654{
3655 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3656 throw std::runtime_error("cb_minus_ctau called with a class whose parent is not NPbase");
3657}
3658
3660{
3661 return myNPbase->cbminusctau();
3662}
3663
3665{
3666 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3667 throw std::runtime_error("cc_minus_ctau called with a class whose parent is not NPbase");
3668}
3669
3671{
3672 return myNPbase->ccminusctau();
3673}
3674
3675
3676// Full signal strengths at e+ e- colliders
3677// ----------------------------------------
3678
3679mueeZHbb::mueeZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3680: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3681{
3682 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3683 throw std::runtime_error("mueeZHbb called with a class whose parent is not NPbase");
3684}
3685
3687{
3688 if ((this->getModel()).isModelLinearized()) {
3689 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
3690 } else {
3691 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHbbRatio());
3692 }
3693}
3694
3695mueeZHcc::mueeZHcc(const StandardModel& SM_i, const double sqrt_s_i)
3696: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3697{
3698 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3699 throw std::runtime_error("mueeZHcc called with a class whose parent is not NPbase");
3700}
3701
3703{
3704 if ((this->getModel()).isModelLinearized()) {
3705 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
3706 } else {
3707 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHccRatio());
3708 }
3709}
3710
3711mueeZHss::mueeZHss(const StandardModel& SM_i, const double sqrt_s_i)
3712: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3713{
3714 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3715 throw std::runtime_error("mueeZHss called with a class whose parent is not NPbase");
3716}
3717
3719{
3720 if ((this->getModel()).isModelLinearized()) {
3721 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHssRatio()) - 1.0);
3722 } else {
3723 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHssRatio());
3724 }
3725}
3726
3727mueeZHgg::mueeZHgg(const StandardModel& SM_i, const double sqrt_s_i)
3728: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3729{
3730 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3731 throw std::runtime_error("mueeZHgg called with a class whose parent is not NPbase");
3732}
3733
3735{
3736 if ((this->getModel()).isModelLinearized()) {
3737 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
3738 } else {
3739 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHggRatio());
3740 }
3741}
3742
3743mueeZHWW::mueeZHWW(const StandardModel& SM_i, const double sqrt_s_i)
3744: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3745{
3746 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3747 throw std::runtime_error("mueeZHWW called with a class whose parent is not NPbase");
3748}
3749
3751{
3752 if ((this->getModel()).isModelLinearized()) {
3753 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
3754 } else {
3755 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHWWRatio());
3756 }
3757}
3758
3759mueeZHtautau::mueeZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3760: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3761{
3762 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3763 throw std::runtime_error("mueeZHtautau called with a class whose parent is not NPbase");
3764}
3765
3767{
3768 if ((this->getModel()).isModelLinearized()) {
3769 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
3770 } else {
3772 }
3773}
3774
3775mueeZHZZ::mueeZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3776: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3777{
3778 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3779 throw std::runtime_error("mueeZHZZ called with a class whose parent is not NPbase");
3780}
3781
3783{
3784 if ((this->getModel()).isModelLinearized()) {
3785 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
3786 } else {
3787 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHZZRatio());
3788 }
3789}
3790
3791mueeZHZga::mueeZHZga(const StandardModel& SM_i, const double sqrt_s_i)
3792: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3793{
3794 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3795 throw std::runtime_error("mueeZHZga called with a class whose parent is not NPbase");
3796}
3797
3799{
3800 if ((this->getModel()).isModelLinearized()) {
3801 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
3802 } else {
3803 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHZgaRatio());
3804 }
3805}
3806
3807mueeZHgaga::mueeZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3808: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3809{
3810 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3811 throw std::runtime_error("mueeZHgaga called with a class whose parent is not NPbase");
3812}
3813
3815{
3816 if ((this->getModel()).isModelLinearized()) {
3817 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
3818 } else {
3819 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHgagaRatio());
3820 }
3821}
3822
3823mueeZHmumu::mueeZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
3824: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3825{
3826 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3827 throw std::runtime_error("mueeZHmumu called with a class whose parent is not NPbase");
3828}
3829
3831{
3832 if ((this->getModel()).isModelLinearized()) {
3833 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
3834 } else {
3835 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->BrHmumuRatio());
3836 }
3837}
3838
3839mueeZHBRinv::mueeZHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3840: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3841{
3842 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3843 throw std::runtime_error("mueeZHBRinv called with a class whose parent is not NPbase");
3844}
3845
3847{
3848
3849 return (myNPbase->mueeZH(sqrt_s))*(myNPbase->Br_H_inv());
3850
3851}
3852
3853mueeZHinv::mueeZHinv(const StandardModel& SM_i, const double sqrt_s_i)
3854: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3855{
3856 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3857 throw std::runtime_error("mueeZHinv called with a class whose parent is not NPbase");
3858}
3859
3861{
3862
3863 if ((this->getModel()).isModelLinearized()) {
3864 return ((myNPbase->mueeZH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3865 } else {
3867 }
3868
3869}
3870
3871mueeZHbbPol::mueeZHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
3872: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
3873{
3874 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3875 throw std::runtime_error("mueeZHbbPol called with a class whose parent is not NPbase");
3876}
3877
3879{
3880 if ((this->getModel()).isModelLinearized()) {
3881 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
3882 } else {
3884 }
3885}
3886
3887mueeZHccPol::mueeZHccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
3888: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
3889{
3890 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3891 throw std::runtime_error("mueeZHccPol called with a class whose parent is not NPbase");
3892}
3893
3895{
3896 if ((this->getModel()).isModelLinearized()) {
3897 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
3898 } else {
3900 }
3901}
3902
3903mueeZHssPol::mueeZHssPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
3904: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
3905{
3906 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3907 throw std::runtime_error("mueeZHssPol called with a class whose parent is not NPbase");
3908}
3909
3911{
3912 if ((this->getModel()).isModelLinearized()) {
3913 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHssRatio()) - 1.0);
3914 } else {
3916 }
3917}
3918
3919mueeZHggPol::mueeZHggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
3920: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
3921{
3922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3923 throw std::runtime_error("mueeZHggPol called with a class whose parent is not NPbase");
3924}
3925
3927{
3928 if ((this->getModel()).isModelLinearized()) {
3929 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
3930 } else {
3932 }
3933}
3934
3935mueeZHWWPol::mueeZHWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
3936: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
3937{
3938 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3939 throw std::runtime_error("mueeZHWWPol called with a class whose parent is not NPbase");
3940}
3941
3943{
3944 if ((this->getModel()).isModelLinearized()) {
3945 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
3946 } else {
3948 }
3949}
3950
3951mueeZHtautauPol::mueeZHtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
3952: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
3953{
3954 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3955 throw std::runtime_error("mueeZHtautauPol called with a class whose parent is not NPbase");
3956}
3957
3959{
3960 if ((this->getModel()).isModelLinearized()) {
3961 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
3962 } else {
3964 }
3965}
3966
3967mueeZHZZPol::mueeZHZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
3968: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
3969{
3970 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3971 throw std::runtime_error("mueeZHZZPol called with a class whose parent is not NPbase");
3972}
3973
3975{
3976 if ((this->getModel()).isModelLinearized()) {
3977 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
3978 } else {
3980 }
3981}
3982
3983mueeZHZgaPol::mueeZHZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
3984: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
3985{
3986 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3987 throw std::runtime_error("mueeZHZgaPol called with a class whose parent is not NPbase");
3988}
3989
3991{
3992 if ((this->getModel()).isModelLinearized()) {
3993 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
3994 } else {
3996 }
3997}
3998
3999mueeZHgagaPol::mueeZHgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4000: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4001{
4002 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4003 throw std::runtime_error("mueeZHgagaPol called with a class whose parent is not NPbase");
4004}
4005
4007{
4008 if ((this->getModel()).isModelLinearized()) {
4009 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4010 } else {
4012 }
4013}
4014
4015mueeZHmumuPol::mueeZHmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4016: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4017{
4018 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4019 throw std::runtime_error("mueeZHmumuPol called with a class whose parent is not NPbase");
4020}
4021
4023{
4024 if ((this->getModel()).isModelLinearized()) {
4025 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4026 } else {
4028 }
4029}
4030
4031mueeZHBRinvPol::mueeZHBRinvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4032: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4033{
4034 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4035 throw std::runtime_error("mueeZHBRinvPol called with a class whose parent is not NPbase");
4036}
4037
4039{
4041
4042}
4043
4044mueeZHinvPol::mueeZHinvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4045: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4046{
4047 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4048 throw std::runtime_error("mueeZHinvPol called with a class whose parent is not NPbase");
4049}
4050
4052{
4053
4054 if ((this->getModel()).isModelLinearized()) {
4055 return ((myNPbase->mueeZHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtoinvRatio()) - 1.0);
4056 } else {
4058 }
4059
4060}
4061
4062mueeWBFbb::mueeWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4063: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4064{
4065 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4066 throw std::runtime_error("mueeWBFbb called with a class whose parent is not NPbase");
4067
4068}
4069
4071{
4072 if ((this->getModel()).isModelLinearized()) {
4073 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4074 } else {
4075 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHbbRatio());
4076 }
4077}
4078
4079mueeWBFbbPol::mueeWBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4080: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4081{
4082 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4083 throw std::runtime_error("mueeWBFbbPol called with a class whose parent is not NPbase");
4084
4085}
4086
4088{
4089 if ((this->getModel()).isModelLinearized()) {
4090 return ((myNPbase->mueeWBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4091 } else {
4093 }
4094}
4095
4096mueeWBFcc::mueeWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
4097: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4098{
4099 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4100 throw std::runtime_error("mueeWBFcc called with a class whose parent is not NPbase");
4101
4102}
4103
4105{
4106 if ((this->getModel()).isModelLinearized()) {
4107 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4108 } else {
4109 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHccRatio());
4110 }
4111}
4112
4113mueeWBFgg::mueeWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
4114: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4115{
4116 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4117 throw std::runtime_error("mueeWBFgg called with a class whose parent is not NPbase");
4118
4119}
4120
4122{
4123 if ((this->getModel()).isModelLinearized()) {
4124 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4125 } else {
4126 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHggRatio());
4127 }
4128}
4129
4130mueeWBFWW::mueeWBFWW(const StandardModel& SM_i, const double sqrt_s_i)
4131: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4132{
4133 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4134 throw std::runtime_error("mueeWBFWW called with a class whose parent is not NPbase");
4135
4136}
4137
4139{
4140 if ((this->getModel()).isModelLinearized()) {
4141 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4142 } else {
4143 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHWWRatio());
4144 }
4145}
4146
4147mueeWBFtautau::mueeWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
4148: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4149{
4150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4151 throw std::runtime_error("mueeWBFtautau called with a class whose parent is not NPbase");
4152
4153}
4154
4156{
4157 if ((this->getModel()).isModelLinearized()) {
4158 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4159 } else {
4161 }
4162}
4163
4164mueeWBFZZ::mueeWBFZZ(const StandardModel& SM_i, const double sqrt_s_i)
4165: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4166{
4167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4168 throw std::runtime_error("mueeWBFZZ called with a class whose parent is not NPbase");
4169
4170}
4171
4173{
4174 if ((this->getModel()).isModelLinearized()) {
4175 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4176 } else {
4177 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZZRatio());
4178 }
4179}
4180
4181mueeWBFZga::mueeWBFZga(const StandardModel& SM_i, const double sqrt_s_i)
4182: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4183{
4184 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4185 throw std::runtime_error("mueeWBFZga called with a class whose parent is not NPbase");
4186
4187}
4188
4190{
4191 if ((this->getModel()).isModelLinearized()) {
4192 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4193 } else {
4194 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZgaRatio());
4195 }
4196}
4197
4198mueeWBFgaga::mueeWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
4199: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4200{
4201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4202 throw std::runtime_error("mueeWBFgaga called with a class whose parent is not NPbase");
4203
4204}
4205
4207{
4208 if ((this->getModel()).isModelLinearized()) {
4209 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4210 } else {
4212 }
4213}
4214
4215mueeWBFmumu::mueeWBFmumu(const StandardModel& SM_i, const double sqrt_s_i)
4216: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4217{
4218 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4219 throw std::runtime_error("mueeWBFmumu called with a class whose parent is not NPbase");
4220
4221}
4222
4224{
4225 if ((this->getModel()).isModelLinearized()) {
4226 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4227 } else {
4229 }
4230}
4231
4232mueeHvvbb::mueeHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
4233: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4234{
4235 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4236 throw std::runtime_error("mueeHvvbb called with a class whose parent is not NPbase");
4237
4238}
4239
4241{
4242 if ((this->getModel()).isModelLinearized()) {
4243 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4244 } else {
4245 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHbbRatio());
4246 }
4247}
4248
4249mueeHvvbbPol::mueeHvvbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4250: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4251{
4252 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4253 throw std::runtime_error("mueeHvvbbPol called with a class whose parent is not NPbase");
4254
4255}
4256
4258{
4259 if ((this->getModel()).isModelLinearized()) {
4260 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4261 } else {
4263 }
4264}
4265
4266mueeHvvcc::mueeHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
4267: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4268{
4269 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4270 throw std::runtime_error("mueeHvvcc called with a class whose parent is not NPbase");
4271
4272}
4273
4275{
4276 if ((this->getModel()).isModelLinearized()) {
4277 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4278 } else {
4279 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHccRatio());
4280 }
4281}
4282
4283mueeHvvccPol::mueeHvvccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4284: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4285{
4286 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4287 throw std::runtime_error("mueeHvvccPol called with a class whose parent is not NPbase");
4288
4289}
4290
4292{
4293 if ((this->getModel()).isModelLinearized()) {
4294 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4295 } else {
4297 }
4298}
4299
4300mueeHvvgg::mueeHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
4301: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4302{
4303 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4304 throw std::runtime_error("mueeHvvgg called with a class whose parent is not NPbase");
4305
4306}
4307
4309{
4310 if ((this->getModel()).isModelLinearized()) {
4311 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4312 } else {
4313 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHggRatio());
4314 }
4315}
4316
4317mueeHvvggPol::mueeHvvggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4318: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4319{
4320 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4321 throw std::runtime_error("mueeHvvggPol called with a class whose parent is not NPbase");
4322
4323}
4324
4326{
4327 if ((this->getModel()).isModelLinearized()) {
4328 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4329 } else {
4331 }
4332}
4333
4334mueeHvvWW::mueeHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
4335: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4336{
4337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4338 throw std::runtime_error("mueeHvvWW called with a class whose parent is not NPbase");
4339
4340}
4341
4343{
4344 if ((this->getModel()).isModelLinearized()) {
4345 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4346 } else {
4347 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHWWRatio());
4348 }
4349}
4350
4351mueeHvvWWPol::mueeHvvWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4352: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4353{
4354 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4355 throw std::runtime_error("mueeHvvWWPol called with a class whose parent is not NPbase");
4356
4357}
4358
4360{
4361 if ((this->getModel()).isModelLinearized()) {
4362 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4363 } else {
4365 }
4366}
4367
4368mueeHvvtautau::mueeHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
4369: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4370{
4371 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4372 throw std::runtime_error("mueeHvvtautau called with a class whose parent is not NPbase");
4373
4374}
4375
4377{
4378 if ((this->getModel()).isModelLinearized()) {
4379 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4380 } else {
4382 }
4383}
4384
4385mueeHvvtautauPol::mueeHvvtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4386: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4387{
4388 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4389 throw std::runtime_error("mueeHvvtautauPol called with a class whose parent is not NPbase");
4390
4391}
4392
4394{
4395 if ((this->getModel()).isModelLinearized()) {
4396 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4397 } else {
4399 }
4400}
4401
4402mueeHvvZZ::mueeHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
4403: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4404{
4405 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4406 throw std::runtime_error("mueeHvvZZ called with a class whose parent is not NPbase");
4407
4408}
4409
4411{
4412 if ((this->getModel()).isModelLinearized()) {
4413 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4414 } else {
4415 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZZRatio());
4416 }
4417}
4418
4419mueeHvvZZPol::mueeHvvZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4420: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4421{
4422 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4423 throw std::runtime_error("mueeHvvZZPol called with a class whose parent is not NPbase");
4424
4425}
4426
4428{
4429 if ((this->getModel()).isModelLinearized()) {
4430 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4431 } else {
4433 }
4434}
4435
4436mueeHvvZga::mueeHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
4437: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4438{
4439 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4440 throw std::runtime_error("mueeHvvZga called with a class whose parent is not NPbase");
4441
4442}
4443
4445{
4446 if ((this->getModel()).isModelLinearized()) {
4447 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4448 } else {
4449 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
4450 }
4451}
4452
4453mueeHvvZgaPol::mueeHvvZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4454: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4455{
4456 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4457 throw std::runtime_error("mueeHvvZgaPol called with a class whose parent is not NPbase");
4458
4459}
4460
4462{
4463 if ((this->getModel()).isModelLinearized()) {
4464 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4465 } else {
4467 }
4468}
4469
4470mueeHvvgaga::mueeHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
4471: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4472{
4473 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4474 throw std::runtime_error("mueeHvvgaga called with a class whose parent is not NPbase");
4475
4476}
4477
4479{
4480 if ((this->getModel()).isModelLinearized()) {
4481 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4482 } else {
4484 }
4485}
4486
4487mueeHvvgagaPol::mueeHvvgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4488: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4489{
4490 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4491 throw std::runtime_error("mueeHvvgagaPol called with a class whose parent is not NPbase");
4492
4493}
4494
4496{
4497 if ((this->getModel()).isModelLinearized()) {
4498 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4499 } else {
4501 }
4502}
4503
4504mueeHvvmumu::mueeHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
4505: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4506{
4507 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4508 throw std::runtime_error("mueeHvvmumu called with a class whose parent is not NPbase");
4509
4510}
4511
4513{
4514 if ((this->getModel()).isModelLinearized()) {
4515 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4516 } else {
4518 }
4519}
4520
4521mueeHvvmumuPol::mueeHvvmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4522: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4523{
4524 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4525 throw std::runtime_error("mueeHvvmumuPol called with a class whose parent is not NPbase");
4526
4527}
4528
4530{
4531 if ((this->getModel()).isModelLinearized()) {
4532 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4533 } else {
4535 }
4536}
4537
4538mueeZBFbb::mueeZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4539: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4540{
4541 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4542 throw std::runtime_error("mueeZBFbb called with a class whose parent is not NPbase");
4543}
4544
4546{
4547 if ((this->getModel()).isModelLinearized()) {
4548 return ((myNPbase->mueeZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4549 } else {
4550 return (myNPbase->mueeZBF(sqrt_s))*(myNPbase->BrHbbRatio());
4551 }
4552}
4553
4554mueeZBFbbPol::mueeZBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4555: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4556{
4557 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4558 throw std::runtime_error("mueeZBFbbPol called with a class whose parent is not NPbase");
4559}
4560
4562{
4563 if ((this->getModel()).isModelLinearized()) {
4564 return ((myNPbase->mueeZBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4565 } else {
4567 }
4568}
4569
4570mueettHbb::mueettHbb(const StandardModel& SM_i, const double sqrt_s_i)
4571: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4572{
4573 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4574 throw std::runtime_error("mueettHbb called with a class whose parent is not NPbase");
4575}
4576
4578{
4579 if ((this->getModel()).isModelLinearized()) {
4580 return ((myNPbase->mueettH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4581 } else {
4582 return (myNPbase->mueettH(sqrt_s))*(myNPbase->BrHbbRatio());
4583 }
4584}
4585
4586mueettHbbPol::mueettHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4587: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4588{
4589 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4590 throw std::runtime_error("mueettHbbPol called with a class whose parent is not NPbase");
4591}
4592
4594{
4595 if ((this->getModel()).isModelLinearized()) {
4596 return ((myNPbase->mueettHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4597 } else {
4599 }
4600}
4601
4602
4603// Production signal strengths at mu+ mu- colliders
4604// ------------------------------------------------
4605
4606mummZH::mummZH(const StandardModel& SM_i, const double sqrt_s_i)
4607: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4608{
4609 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4610 throw std::runtime_error("mummZH called with a class whose parent is not NPbase");
4611}
4612
4614{
4615 return myNPbase->mummZH(sqrt_s);
4616}
4617
4618
4619mummHvv::mummHvv(const StandardModel& SM_i, const double sqrt_s_i)
4620: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4621{
4622 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4623 throw std::runtime_error("mummHvv called with a class whose parent is not NPbase");
4624}
4625
4627{
4628 return myNPbase->mummHvv(sqrt_s);
4629}
4630
4631
4632mummttH::mummttH(const StandardModel& SM_i, const double sqrt_s_i)
4633: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4634{
4635 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4636 throw std::runtime_error("mummttH called with a class whose parent is not NPbase");
4637}
4638
4640{
4641 return myNPbase->mummttH(sqrt_s);
4642}
4643
4644
4645// Full signal strengths at mu+ mu- colliders
4646// -------------------------------------------
4647
4648
4649mummHbb::mummHbb(const StandardModel& SM_i, const double sqrt_s_i)
4650: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4651{
4652 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4653 throw std::runtime_error("mummHbb called with a class whose parent is not NPbase");
4654}
4655
4657{
4658 if ((this->getModel()).isModelLinearized()) {
4659 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4660 } else {
4661 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHbbRatio());
4662 }
4663}
4664
4665mummHcc::mummHcc(const StandardModel& SM_i, const double sqrt_s_i)
4666: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4667{
4668 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4669 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
4670}
4671
4673{
4674 if ((this->getModel()).isModelLinearized()) {
4675 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4676 } else {
4677 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHccRatio());
4678 }
4679}
4680
4681mummHgg::mummHgg(const StandardModel& SM_i, const double sqrt_s_i)
4682: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4683{
4684 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4685 throw std::runtime_error("mummHgg called with a class whose parent is not NPbase");
4686}
4687
4689{
4690 if ((this->getModel()).isModelLinearized()) {
4691 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4692 } else {
4693 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHggRatio());
4694 }
4695}
4696
4697mummHWW::mummHWW(const StandardModel& SM_i, const double sqrt_s_i)
4698: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4699{
4700 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4701 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
4702}
4703
4705{
4706 if ((this->getModel()).isModelLinearized()) {
4707 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4708 } else {
4709 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHWWRatio());
4710 }
4711}
4712
4713mummHtautau::mummHtautau(const StandardModel& SM_i, const double sqrt_s_i)
4714: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4715{
4716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4717 throw std::runtime_error("mummHtautau called with a class whose parent is not NPbase");
4718}
4719
4721{
4722 if ((this->getModel()).isModelLinearized()) {
4723 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4724 } else {
4726 }
4727}
4728
4729mummHZZ::mummHZZ(const StandardModel& SM_i, const double sqrt_s_i)
4730: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4731{
4732 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4733 throw std::runtime_error("mummHZZ called with a class whose parent is not NPbase");
4734}
4735
4737{
4738 if ((this->getModel()).isModelLinearized()) {
4739 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4740 } else {
4741 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZZRatio());
4742 }
4743}
4744
4745mummHZga::mummHZga(const StandardModel& SM_i, const double sqrt_s_i)
4746: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4747{
4748 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4749 throw std::runtime_error("mummHZga called with a class whose parent is not NPbase");
4750}
4751
4753{
4754 if ((this->getModel()).isModelLinearized()) {
4755 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4756 } else {
4757 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZgaRatio());
4758 }
4759}
4760
4761mummHgaga::mummHgaga(const StandardModel& SM_i, const double sqrt_s_i)
4762: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4763{
4764 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4765 throw std::runtime_error("mummHgaga called with a class whose parent is not NPbase");
4766}
4767
4769{
4770 if ((this->getModel()).isModelLinearized()) {
4771 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4772 } else {
4773 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHgagaRatio());
4774 }
4775}
4776
4777mummHmumu::mummHmumu(const StandardModel& SM_i, const double sqrt_s_i)
4778: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4779{
4780 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4781 throw std::runtime_error("mummHmumu called with a class whose parent is not NPbase");
4782}
4783
4785{
4786 if ((this->getModel()).isModelLinearized()) {
4787 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4788 } else {
4789 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHmumuRatio());
4790 }
4791}
4792
4793
4794
4795mummZHbb::mummZHbb(const StandardModel& SM_i, const double sqrt_s_i)
4796: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4797{
4798 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4799 throw std::runtime_error("mummZHbb called with a class whose parent is not NPbase");
4800}
4801
4803{
4804 if ((this->getModel()).isModelLinearized()) {
4805 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4806 } else {
4807 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHbbRatio());
4808 }
4809}
4810
4811mummZHcc::mummZHcc(const StandardModel& SM_i, const double sqrt_s_i)
4812: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4813{
4814 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4815 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
4816}
4817
4819{
4820 if ((this->getModel()).isModelLinearized()) {
4821 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4822 } else {
4823 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHccRatio());
4824 }
4825}
4826
4827mummZHgg::mummZHgg(const StandardModel& SM_i, const double sqrt_s_i)
4828: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4829{
4830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4831 throw std::runtime_error("mummZHgg called with a class whose parent is not NPbase");
4832}
4833
4835{
4836 if ((this->getModel()).isModelLinearized()) {
4837 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4838 } else {
4839 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHggRatio());
4840 }
4841}
4842
4843mummZHWW::mummZHWW(const StandardModel& SM_i, const double sqrt_s_i)
4844: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4845{
4846 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4847 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
4848}
4849
4851{
4852 if ((this->getModel()).isModelLinearized()) {
4853 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4854 } else {
4855 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHWWRatio());
4856 }
4857}
4858
4859mummZHtautau::mummZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
4860: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4861{
4862 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4863 throw std::runtime_error("mummZHtautau called with a class whose parent is not NPbase");
4864}
4865
4867{
4868 if ((this->getModel()).isModelLinearized()) {
4869 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4870 } else {
4872 }
4873}
4874
4875mummZHZZ::mummZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
4876: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4877{
4878 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4879 throw std::runtime_error("mummZHZZ called with a class whose parent is not NPbase");
4880}
4881
4883{
4884 if ((this->getModel()).isModelLinearized()) {
4885 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4886 } else {
4887 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZZRatio());
4888 }
4889}
4890
4891mummZHZga::mummZHZga(const StandardModel& SM_i, const double sqrt_s_i)
4892: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4893{
4894 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4895 throw std::runtime_error("mummZHZga called with a class whose parent is not NPbase");
4896}
4897
4899{
4900 if ((this->getModel()).isModelLinearized()) {
4901 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4902 } else {
4903 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZgaRatio());
4904 }
4905}
4906
4907mummZHgaga::mummZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
4908: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4909{
4910 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4911 throw std::runtime_error("mummZHgaga called with a class whose parent is not NPbase");
4912}
4913
4915{
4916 if ((this->getModel()).isModelLinearized()) {
4917 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4918 } else {
4919 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHgagaRatio());
4920 }
4921}
4922
4923mummZHmumu::mummZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
4924: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4925{
4926 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4927 throw std::runtime_error("mummZHmumu called with a class whose parent is not NPbase");
4928}
4929
4931{
4932 if ((this->getModel()).isModelLinearized()) {
4933 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4934 } else {
4935 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHmumuRatio());
4936 }
4937}
4938
4939
4940
4941mummHvvbb::mummHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
4942: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4943{
4944 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4945 throw std::runtime_error("mummHvvbb called with a class whose parent is not NPbase");
4946}
4947
4949{
4950 if ((this->getModel()).isModelLinearized()) {
4951 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4952 } else {
4953 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHbbRatio());
4954 }
4955}
4956
4957mummHvvcc::mummHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
4958: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4959{
4960 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4961 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
4962}
4963
4965{
4966 if ((this->getModel()).isModelLinearized()) {
4967 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4968 } else {
4969 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHccRatio());
4970 }
4971}
4972
4973mummHvvgg::mummHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
4974: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4975{
4976 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4977 throw std::runtime_error("mummHvvgg called with a class whose parent is not NPbase");
4978}
4979
4981{
4982 if ((this->getModel()).isModelLinearized()) {
4983 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4984 } else {
4985 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHggRatio());
4986 }
4987}
4988
4989mummHvvWW::mummHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
4990: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4991{
4992 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4993 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
4994}
4995
4997{
4998 if ((this->getModel()).isModelLinearized()) {
4999 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5000 } else {
5001 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHWWRatio());
5002 }
5003}
5004
5005mummHvvtautau::mummHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
5006: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5007{
5008 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5009 throw std::runtime_error("mummHvvtautau called with a class whose parent is not NPbase");
5010}
5011
5013{
5014 if ((this->getModel()).isModelLinearized()) {
5015 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5016 } else {
5018 }
5019}
5020
5021mummHvvZZ::mummHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
5022: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5023{
5024 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5025 throw std::runtime_error("mummHvvZZ called with a class whose parent is not NPbase");
5026}
5027
5029{
5030 if ((this->getModel()).isModelLinearized()) {
5031 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5032 } else {
5033 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZZRatio());
5034 }
5035}
5036
5037mummHvvZga::mummHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
5038: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5039{
5040 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5041 throw std::runtime_error("mummHvvZga called with a class whose parent is not NPbase");
5042}
5043
5045{
5046 if ((this->getModel()).isModelLinearized()) {
5047 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5048 } else {
5049 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
5050 }
5051}
5052
5053mummHvvgaga::mummHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
5054: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5055{
5056 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5057 throw std::runtime_error("mummHvvgaga called with a class whose parent is not NPbase");
5058}
5059
5061{
5062 if ((this->getModel()).isModelLinearized()) {
5063 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5064 } else {
5066 }
5067}
5068
5069mummHvvmumu::mummHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
5070: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5071{
5072 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5073 throw std::runtime_error("mummHvvmumu called with a class whose parent is not NPbase");
5074}
5075
5077{
5078 if ((this->getModel()).isModelLinearized()) {
5079 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5080 } else {
5082 }
5083}
5084
5085
5086
5087mummHmmbb::mummHmmbb(const StandardModel& SM_i, const double sqrt_s_i)
5088: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5089{
5090 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5091 throw std::runtime_error("mummHmmbb called with a class whose parent is not NPbase");
5092}
5093
5095{
5096 if ((this->getModel()).isModelLinearized()) {
5097 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5098 } else {
5099 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHbbRatio());
5100 }
5101}
5102
5103mummHmmcc::mummHmmcc(const StandardModel& SM_i, const double sqrt_s_i)
5104: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5105{
5106 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5107 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5108}
5109
5111{
5112 if ((this->getModel()).isModelLinearized()) {
5113 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5114 } else {
5115 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHccRatio());
5116 }
5117}
5118
5119mummHmmgg::mummHmmgg(const StandardModel& SM_i, const double sqrt_s_i)
5120: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5121{
5122 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5123 throw std::runtime_error("mummHmmgg called with a class whose parent is not NPbase");
5124}
5125
5127{
5128 if ((this->getModel()).isModelLinearized()) {
5129 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5130 } else {
5131 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHggRatio());
5132 }
5133}
5134
5135mummHmmWW::mummHmmWW(const StandardModel& SM_i, const double sqrt_s_i)
5136: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5137{
5138 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5139 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5140}
5141
5143{
5144 if ((this->getModel()).isModelLinearized()) {
5145 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5146 } else {
5147 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHWWRatio());
5148 }
5149}
5150
5151mummHmmtautau::mummHmmtautau(const StandardModel& SM_i, const double sqrt_s_i)
5152: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5153{
5154 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5155 throw std::runtime_error("mummHmmtautau called with a class whose parent is not NPbase");
5156}
5157
5159{
5160 if ((this->getModel()).isModelLinearized()) {
5161 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5162 } else {
5164 }
5165}
5166
5167mummHmmZZ::mummHmmZZ(const StandardModel& SM_i, const double sqrt_s_i)
5168: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5169{
5170 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5171 throw std::runtime_error("mummHmmZZ called with a class whose parent is not NPbase");
5172}
5173
5175{
5176 if ((this->getModel()).isModelLinearized()) {
5177 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5178 } else {
5179 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZZRatio());
5180 }
5181}
5182
5183mummHmmZga::mummHmmZga(const StandardModel& SM_i, const double sqrt_s_i)
5184: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5185{
5186 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5187 throw std::runtime_error("mummHmmZga called with a class whose parent is not NPbase");
5188}
5189
5191{
5192 if ((this->getModel()).isModelLinearized()) {
5193 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5194 } else {
5195 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZgaRatio());
5196 }
5197}
5198
5199mummHmmgaga::mummHmmgaga(const StandardModel& SM_i, const double sqrt_s_i)
5200: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5201{
5202 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5203 throw std::runtime_error("mummHmmgaga called with a class whose parent is not NPbase");
5204}
5205
5207{
5208 if ((this->getModel()).isModelLinearized()) {
5209 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5210 } else {
5212 }
5213}
5214
5215mummHmmmumu::mummHmmmumu(const StandardModel& SM_i, const double sqrt_s_i)
5216: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5217{
5218 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5219 throw std::runtime_error("mummHmmmumu called with a class whose parent is not NPbase");
5220}
5221
5223{
5224 if ((this->getModel()).isModelLinearized()) {
5225 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5226 } else {
5228 }
5229}
5230
5231
5232mummttHbb::mummttHbb(const StandardModel& SM_i, const double sqrt_s_i)
5233: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5234{
5235 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5236 throw std::runtime_error("mummttHbb called with a class whose parent is not NPbase");
5237}
5238
5240{
5241 if ((this->getModel()).isModelLinearized()) {
5242 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5243 } else {
5244 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHbbRatio());
5245 }
5246}
5247
5248mummttHcc::mummttHcc(const StandardModel& SM_i, const double sqrt_s_i)
5249: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5250{
5251 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5252 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5253}
5254
5256{
5257 if ((this->getModel()).isModelLinearized()) {
5258 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5259 } else {
5260 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHccRatio());
5261 }
5262}
5263
5264mummttHgg::mummttHgg(const StandardModel& SM_i, const double sqrt_s_i)
5265: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5266{
5267 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5268 throw std::runtime_error("mummttHgg called with a class whose parent is not NPbase");
5269}
5270
5272{
5273 if ((this->getModel()).isModelLinearized()) {
5274 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5275 } else {
5276 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHggRatio());
5277 }
5278}
5279
5280mummttHWW::mummttHWW(const StandardModel& SM_i, const double sqrt_s_i)
5281: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5282{
5283 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5284 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5285}
5286
5288{
5289 if ((this->getModel()).isModelLinearized()) {
5290 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5291 } else {
5292 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHWWRatio());
5293 }
5294}
5295
5296mummttHtautau::mummttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5297: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5298{
5299 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5300 throw std::runtime_error("mummttHtautau called with a class whose parent is not NPbase");
5301}
5302
5304{
5305 if ((this->getModel()).isModelLinearized()) {
5306 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5307 } else {
5309 }
5310}
5311
5312mummttHZZ::mummttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5313: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5314{
5315 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5316 throw std::runtime_error("mummttHZZ called with a class whose parent is not NPbase");
5317}
5318
5320{
5321 if ((this->getModel()).isModelLinearized()) {
5322 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5323 } else {
5324 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZZRatio());
5325 }
5326}
5327
5328mummttHZga::mummttHZga(const StandardModel& SM_i, const double sqrt_s_i)
5329: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5330{
5331 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5332 throw std::runtime_error("mummttHZga called with a class whose parent is not NPbase");
5333}
5334
5336{
5337 if ((this->getModel()).isModelLinearized()) {
5338 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5339 } else {
5340 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZgaRatio());
5341 }
5342}
5343
5344mummttHgaga::mummttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5345: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5346{
5347 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5348 throw std::runtime_error("mummttHgaga called with a class whose parent is not NPbase");
5349}
5350
5352{
5353 if ((this->getModel()).isModelLinearized()) {
5354 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5355 } else {
5357 }
5358}
5359
5360mummttHmumu::mummttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5361: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5362{
5363 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5364 throw std::runtime_error("mummttHmumu called with a class whose parent is not NPbase");
5365}
5366
5368{
5369 if ((this->getModel()).isModelLinearized()) {
5370 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5371 } else {
5373 }
5374}
5375
5376
5377// The same in the narrow width approximation
5378
5379mummHbbNWA::mummHbbNWA(const StandardModel& SM_i, const double sqrt_s_i)
5380: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5381{
5382 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5383 throw std::runtime_error("mummHbbNWA called with a class whose parent is not NPbase");
5384}
5385
5387{
5388 if ((this->getModel()).isModelLinearized()) {
5389 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5390 } else {
5391 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHbbRatio());
5392 }
5393}
5394
5395mummHccNWA::mummHccNWA(const StandardModel& SM_i, const double sqrt_s_i)
5396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5397{
5398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5399 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5400}
5401
5403{
5404 if ((this->getModel()).isModelLinearized()) {
5405 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5406 } else {
5407 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHccRatio());
5408 }
5409}
5410
5411mummHggNWA::mummHggNWA(const StandardModel& SM_i, const double sqrt_s_i)
5412: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5413{
5414 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5415 throw std::runtime_error("mummHggNWA called with a class whose parent is not NPbase");
5416}
5417
5419{
5420 if ((this->getModel()).isModelLinearized()) {
5421 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5422 } else {
5423 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHggRatio());
5424 }
5425}
5426
5427mummHWWNWA::mummHWWNWA(const StandardModel& SM_i, const double sqrt_s_i)
5428: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5429{
5430 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5431 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5432}
5433
5435{
5436 if ((this->getModel()).isModelLinearized()) {
5437 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5438 } else {
5439 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHWWRatio());
5440 }
5441}
5442
5443mummHtautauNWA::mummHtautauNWA(const StandardModel& SM_i, const double sqrt_s_i)
5444: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5445{
5446 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5447 throw std::runtime_error("mummHtautauNWA called with a class whose parent is not NPbase");
5448}
5449
5451{
5452 if ((this->getModel()).isModelLinearized()) {
5453 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5454 } else {
5456 }
5457}
5458
5459mummHZZNWA::mummHZZNWA(const StandardModel& SM_i, const double sqrt_s_i)
5460: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5461{
5462 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5463 throw std::runtime_error("mummHZZNWA called with a class whose parent is not NPbase");
5464}
5465
5467{
5468 if ((this->getModel()).isModelLinearized()) {
5469 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5470 } else {
5471 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHZZRatio());
5472 }
5473}
5474
5475mummHZgaNWA::mummHZgaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5476: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5477{
5478 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5479 throw std::runtime_error("mummHZgaNWA called with a class whose parent is not NPbase");
5480}
5481
5483{
5484 if ((this->getModel()).isModelLinearized()) {
5485 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5486 } else {
5488 }
5489}
5490
5491mummHgagaNWA::mummHgagaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5492: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5493{
5494 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5495 throw std::runtime_error("mummHgagaNWA called with a class whose parent is not NPbase");
5496}
5497
5499{
5500 if ((this->getModel()).isModelLinearized()) {
5501 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5502 } else {
5504 }
5505}
5506
5507mummHmumuNWA::mummHmumuNWA(const StandardModel& SM_i, const double sqrt_s_i)
5508: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5509{
5510 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5511 throw std::runtime_error("mummHmumuNWA called with a class whose parent is not NPbase");
5512}
5513
5515{
5516 if ((this->getModel()).isModelLinearized()) {
5517 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5518 } else {
5520 }
5521}
5522
5523// Full signal strengths at ep colliders
5524// -------------------------------------
5525
5526muepWBFbb::muepWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5527: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5528{
5529 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5530 throw std::runtime_error("muepWBFbb called with a class whose parent is not NPbase");
5531
5532}
5533
5535{
5536 if ((this->getModel()).isModelLinearized()) {
5537 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5538 } else {
5539 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHbbRatio());
5540 }
5541}
5542
5543muepWBFcc::muepWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5544: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5545{
5546 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5547 throw std::runtime_error("muepWBFcc called with a class whose parent is not NPbase");
5548
5549}
5550
5552{
5553 if ((this->getModel()).isModelLinearized()) {
5554 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5555 } else {
5556 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHccRatio());
5557 }
5558}
5559
5560muepWBFgg::muepWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5561: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5562{
5563 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5564 throw std::runtime_error("muepWBFgg called with a class whose parent is not NPbase");
5565
5566}
5567
5569{
5570 if ((this->getModel()).isModelLinearized()) {
5571 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5572 } else {
5573 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHggRatio());
5574 }
5575}
5576
5577muepWBFWW2l2v::muepWBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
5578: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5579{
5580 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5581 throw std::runtime_error("muepWBFWW2l2v called with a class whose parent is not NPbase");
5582
5583}
5584
5586{
5587 if ((this->getModel()).isModelLinearized()) {
5588 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
5589 } else {
5591 }
5592}
5593
5594muepWBFZZ4l::muepWBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
5595: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5596{
5597 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5598 throw std::runtime_error("muepWBFZZ4l called with a class whose parent is not NPbase");
5599
5600}
5601
5603{
5604 if ((this->getModel()).isModelLinearized()) {
5605 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5606 } else {
5607 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrH4lRatio());
5608 }
5609}
5610
5611muepWBFgaga::muepWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
5612: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5613{
5614 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5615 throw std::runtime_error("muepWBFgaga called with a class whose parent is not NPbase");
5616
5617}
5618
5620{
5621 if ((this->getModel()).isModelLinearized()) {
5622 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5623 } else {
5625 }
5626}
5627
5628muepWBFtautau::muepWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
5629: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5630{
5631 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5632 throw std::runtime_error("muepWBFtautau called with a class whose parent is not NPbase");
5633
5634}
5635
5637{
5638 if ((this->getModel()).isModelLinearized()) {
5639 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5640 } else {
5642 }
5643}
5644
5645muepZBFbb::muepZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5646: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5647{
5648 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5649 throw std::runtime_error("muepZBFbb called with a class whose parent is not NPbase");
5650
5651}
5652
5654{
5655 if ((this->getModel()).isModelLinearized()) {
5656 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5657 } else {
5658 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHbbRatio());
5659 }
5660}
5661
5662muepZBFcc::muepZBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5663: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5664{
5665 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5666 throw std::runtime_error("muepZBFcc called with a class whose parent is not NPbase");
5667
5668}
5669
5671{
5672 if ((this->getModel()).isModelLinearized()) {
5673 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5674 } else {
5675 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHccRatio());
5676 }
5677}
5678
5679muepZBFgg::muepZBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5680: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5681{
5682 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5683 throw std::runtime_error("muepZBFgg called with a class whose parent is not NPbase");
5684
5685}
5686
5688{
5689 if ((this->getModel()).isModelLinearized()) {
5690 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5691 } else {
5692 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHggRatio());
5693 }
5694}
5695
5696muepZBFWW2l2v::muepZBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
5697: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5698{
5699 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5700 throw std::runtime_error("muepZBFWW2l2v called with a class whose parent is not NPbase");
5701
5702}
5703
5705{
5706 if ((this->getModel()).isModelLinearized()) {
5707 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
5708 } else {
5710 }
5711}
5712
5713muepZBFZZ4l::muepZBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
5714: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5715{
5716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5717 throw std::runtime_error("muepZBFZZ4l called with a class whose parent is not NPbase");
5718
5719}
5720
5722{
5723 if ((this->getModel()).isModelLinearized()) {
5724 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5725 } else {
5726 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrH4lRatio());
5727 }
5728}
5729
5730muepZBFgaga::muepZBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
5731: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5732{
5733 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5734 throw std::runtime_error("muepZBFgaga called with a class whose parent is not NPbase");
5735
5736}
5737
5739{
5740 if ((this->getModel()).isModelLinearized()) {
5741 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5742 } else {
5744 }
5745}
5746
5747muepZBFtautau::muepZBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
5748: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5749{
5750 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5751 throw std::runtime_error("muepZBFtautau called with a class whose parent is not NPbase");
5752
5753}
5754
5756{
5757 if ((this->getModel()).isModelLinearized()) {
5758 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5759 } else {
5761 }
5762}
5763
5764
5765// -----------------------------------------------------------------------------
5766// STXS bins
5767// -----------------------------------------------------------------------------
5768
5769// -----------------------------------------------------------------------------
5770// Stage 0
5771// -----------------------------------------------------------------------------
5772
5773STXS_0_qqH::STXS_0_qqH(const StandardModel& SM_i, const double sqrt_s_i)
5774: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5775{
5776 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5777 throw std::runtime_error("STXS_0_qqH called with a class whose parent is not NPbase");
5778
5779}
5780
5782{
5783 return myNPbase->STXS0_qqH(sqrt_s);
5784}
5785
5786
5787// -----------------------------------------------------------------------------
5788// Stage 1
5789// -----------------------------------------------------------------------------
5790
5792: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5793{
5794 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5795 throw std::runtime_error("STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
5796
5797}
5798
5800{
5801 if ((this->getModel()).isModelLinearized()) {
5802 return ((myNPbase->STXS_ggH_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5803 } else {
5805 }
5806}
5807
5808
5810: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5811{
5812 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5813 throw std::runtime_error("STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
5814
5815}
5816
5818{
5819 if ((this->getModel()).isModelLinearized()) {
5820 return ((myNPbase->STXS_ggH_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5821 } else {
5823 }
5824}
5825
5826
5827STXSggH0j4l::STXSggH0j4l(const StandardModel& SM_i, const double sqrt_s_i)
5828: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5829{
5830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5831 throw std::runtime_error("STXSggH0j4l called with a class whose parent is not NPbase");
5832
5833}
5834
5836{
5837 if ((this->getModel()).isModelLinearized()) {
5838 return ((myNPbase->STXS_ggH0j(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5839 } else {
5841 }
5842}
5843
5845: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5846{
5847 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5848 throw std::runtime_error("STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
5849
5850}
5851
5853{
5854 if ((this->getModel()).isModelLinearized()) {
5855 return ((myNPbase->STXS_ggH1j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5856 } else {
5858 }
5859}
5860
5862: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5863{
5864 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5865 throw std::runtime_error("STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
5866
5867}
5868
5870{
5871 if ((this->getModel()).isModelLinearized()) {
5872 return ((myNPbase->STXS_ggH1j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5873 } else {
5875 }
5876}
5877
5879: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5880{
5881 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5882 throw std::runtime_error("STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
5883
5884}
5885
5887{
5888 if ((this->getModel()).isModelLinearized()) {
5889 return ((myNPbase->STXS_ggH1j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5890 } else {
5892 }
5893}
5894
5896: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5897{
5898 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5899 throw std::runtime_error("STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
5900
5901}
5902
5904{
5905 if ((this->getModel()).isModelLinearized()) {
5906 return ((myNPbase->STXS_ggH1j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5907 } else {
5909 }
5910}
5911
5913: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5914{
5915 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5916 throw std::runtime_error("STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
5917
5918}
5919
5921{
5922 if ((this->getModel()).isModelLinearized()) {
5923 return ((myNPbase->STXS_ggH2j_pTH_0_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5924 } else {
5926 }
5927}
5928
5929
5931: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5932{
5933 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5934 throw std::runtime_error("STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
5935
5936}
5937
5939{
5940 if ((this->getModel()).isModelLinearized()) {
5941 return ((myNPbase->STXS_ggH2j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5942 } else {
5944 }
5945}
5946
5947
5949: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5950{
5951 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5952 throw std::runtime_error("STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
5953
5954}
5955
5957{
5958 if ((this->getModel()).isModelLinearized()) {
5959 return ((myNPbase->STXS_ggH2j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5960 } else {
5962 }
5963}
5964
5965
5967: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5968{
5969 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5970 throw std::runtime_error("STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
5971
5972}
5973
5975{
5976 if ((this->getModel()).isModelLinearized()) {
5977 return ((myNPbase->STXS_ggH2j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5978 } else {
5980 }
5981}
5982
5983
5985: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5986{
5987 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5988 throw std::runtime_error("STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
5989
5990}
5991
5993{
5994 if ((this->getModel()).isModelLinearized()) {
5995 return ((myNPbase->STXS_ggH2j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5996 } else {
5998 }
5999}
6000
6001
6003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6004{
6005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6006 throw std::runtime_error("STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6007
6008}
6009
6011{
6012 if ((this->getModel()).isModelLinearized()) {
6013 return ((myNPbase->STXS_qqHqq_VBFtopo_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6014 } else {
6016 }
6017}
6018
6019
6021: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6022{
6023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6024 throw std::runtime_error("STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6025
6026}
6027
6029{
6030 if ((this->getModel()).isModelLinearized()) {
6031 return ((myNPbase->STXS_qqHqq_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6032 } else {
6034 }
6035}
6036
6037
6038
6040: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6041{
6042 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6043 throw std::runtime_error("STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6044
6045}
6046
6048{
6049 if ((this->getModel()).isModelLinearized()) {
6050 return ((myNPbase->STXS_qqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6051 } else {
6053 }
6054}
6055
6056
6057
6059: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6060{
6061 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6062 throw std::runtime_error("STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6063
6064}
6065
6067{
6068 if ((this->getModel()).isModelLinearized()) {
6069 return ((myNPbase->STXS_qqHqq_nonVHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6070 } else {
6072 }
6073}
6074
6075
6076
6078: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6079{
6080 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6081 throw std::runtime_error("STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6082
6083}
6084
6086{
6087 if ((this->getModel()).isModelLinearized()) {
6088 return ((myNPbase->STXS_qqHqq_VHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6089 } else {
6091 }
6092}
6093
6094
6095STXSqqHqq_Rest_4l::STXSqqHqq_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i)
6096: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6097{
6098 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6099 throw std::runtime_error("STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6100
6101}
6102
6104{
6105 if ((this->getModel()).isModelLinearized()) {
6106 return ((myNPbase->STXS_qqHqq_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6107 } else {
6109 }
6110}
6111
6112
6114: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6115{
6116 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6117 throw std::runtime_error("STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6118
6119}
6120
6122{
6123 if ((this->getModel()).isModelLinearized()) {
6124 return ((myNPbase->STXS_qqHqq_pTj_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6125 } else {
6127 }
6128}
6129
6131: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6132{
6133 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6134 throw std::runtime_error("STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6135
6136}
6137
6139{
6140 if ((this->getModel()).isModelLinearized()) {
6141 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6142 } else {
6144 }
6145}
6146
6147
6149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6150{
6151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6152 throw std::runtime_error("STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6153
6154}
6155
6157{
6158 if ((this->getModel()).isModelLinearized()) {
6159 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6160 } else {
6162 }
6163}
6164
6165
6166
6168: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6169{
6170 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6171 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6172
6173}
6174
6176{
6177 if ((this->getModel()).isModelLinearized()) {
6179 } else {
6181 }
6182}
6183
6184
6185
6187: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6188{
6189 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6190 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6191
6192}
6193
6195{
6196 if ((this->getModel()).isModelLinearized()) {
6198 } else {
6200 }
6201}
6202
6203
6205: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6206{
6207 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6208 throw std::runtime_error("STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6209
6210}
6211
6213{
6214 if ((this->getModel()).isModelLinearized()) {
6215 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6216 } else {
6218 }
6219}
6220
6222: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6223{
6224 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6225 throw std::runtime_error("STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6226
6227}
6228
6230{
6231 if ((this->getModel()).isModelLinearized()) {
6232 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6233 } else {
6235 }
6236}
6237
6239: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6240{
6241 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6242 throw std::runtime_error("STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6243
6244}
6245
6247{
6248 if ((this->getModel()).isModelLinearized()) {
6249 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6250 } else {
6252 }
6253}
6254
6255
6257: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6258{
6259 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6260 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6261
6262}
6263
6265{
6266 if ((this->getModel()).isModelLinearized()) {
6268 } else {
6270 }
6271}
6272
6273
6275: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6276{
6277 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6278 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6279
6280}
6281
6283{
6284 if ((this->getModel()).isModelLinearized()) {
6286 } else {
6288 }
6289}
6290
6291
6293: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6294{
6295 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6296 throw std::runtime_error("STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6297
6298}
6299
6301{
6302 if ((this->getModel()).isModelLinearized()) {
6303 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6304 } else {
6306 }
6307}
6308
6309STXSttHtH4l::STXSttHtH4l(const StandardModel& SM_i, const double sqrt_s_i)
6310: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6311{
6312 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6313 throw std::runtime_error("STXSttHtH4l called with a class whose parent is not NPbase");
6314
6315}
6316
6318{
6319 if ((this->getModel()).isModelLinearized()) {
6320 return ((myNPbase->STXS_ttHtH(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6321 } else {
6323 }
6324}
6325
6326
6328: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6329{
6330 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6331 throw std::runtime_error("STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6332
6333}
6334
6336{
6337 if ((this->getModel()).isModelLinearized()) {
6338 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6339 } else {
6341 }
6342}
6343
6344
6346: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6347{
6348 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6349 throw std::runtime_error("STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6350
6351}
6352
6354{
6355 if ((this->getModel()).isModelLinearized()) {
6356 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6357 } else {
6359 }
6360}
6361
6362
6363
6365: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6366{
6367 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6368 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6369
6370}
6371
6373{
6374 if ((this->getModel()).isModelLinearized()) {
6376 } else {
6378 }
6379}
6380
6381
6382
6384: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6385{
6386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6387 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6388
6389}
6390
6392{
6393 if ((this->getModel()).isModelLinearized()) {
6395 } else {
6397 }
6398}
6399
6400
6402: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6403{
6404 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6405 throw std::runtime_error("STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6406
6407}
6408
6410{
6411 if ((this->getModel()).isModelLinearized()) {
6412 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6413 } else {
6415 }
6416}
6417
6419: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6420{
6421 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6422 throw std::runtime_error("STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6423
6424}
6425
6427{
6428 if ((this->getModel()).isModelLinearized()) {
6429 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6430 } else {
6432 }
6433}
6434
6436: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6437{
6438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6439 throw std::runtime_error("STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6440
6441}
6442
6444{
6445 if ((this->getModel()).isModelLinearized()) {
6446 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6447 } else {
6449 }
6450}
6451
6452
6454: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6455{
6456 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6457 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6458
6459}
6460
6462{
6463 if ((this->getModel()).isModelLinearized()) {
6465 } else {
6467 }
6468}
6469
6470
6472: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6473{
6474 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6475 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6476
6477}
6478
6480{
6481 if ((this->getModel()).isModelLinearized()) {
6483 } else {
6485 }
6486}
6487
6488
6490: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6491{
6492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6493 throw std::runtime_error("STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6494
6495}
6496
6498{
6499 if ((this->getModel()).isModelLinearized()) {
6500 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6501 } else {
6503 }
6504}
6505
6506
6508: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6509{
6510 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6511 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6512
6513}
6514
6516{
6517 if ((this->getModel()).isModelLinearized()) {
6519 } else {
6521 }
6522}
6523
6524
6526: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6527{
6528 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6529 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6530
6531}
6532
6534{
6535 if ((this->getModel()).isModelLinearized()) {
6536 return ((myNPbase->STXS_WHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6537 } else {
6539 }
6540}
6541
6542
6544: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6545{
6546 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6547 throw std::runtime_error("STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6548
6549}
6550
6552{
6553 if ((this->getModel()).isModelLinearized()) {
6554 return ((myNPbase->STXS_WHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6555 } else {
6557 }
6558}
6559
6560
6562: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6563{
6564 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6565 throw std::runtime_error("STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6566
6567}
6568
6570{
6571 if ((this->getModel()).isModelLinearized()) {
6572 return ((myNPbase->STXS_WHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6573 } else {
6575 }
6576}
6577
6578
6580: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6581{
6582 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6583 throw std::runtime_error("STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6584
6585}
6586
6588{
6589 if ((this->getModel()).isModelLinearized()) {
6590 return ((myNPbase->STXS_WHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6591 } else {
6593 }
6594}
6595
6596
6598: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6599{
6600 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6601 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6602
6603}
6604
6606{
6607 if ((this->getModel()).isModelLinearized()) {
6609 } else {
6611 }
6612}
6613
6614
6616: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6617{
6618 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6619 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6620
6621}
6622
6624{
6625 if ((this->getModel()).isModelLinearized()) {
6626 return ((myNPbase->STXS_ZHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6627 } else {
6629 }
6630}
6631
6632
6634: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6635{
6636 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6637 throw std::runtime_error("STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6638
6639}
6640
6642{
6643 if ((this->getModel()).isModelLinearized()) {
6644 return ((myNPbase->STXS_ZHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6645 } else {
6647 }
6648}
6649
6650
6652: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6653{
6654 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6655 throw std::runtime_error("STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6656
6657}
6658
6660{
6661 if ((this->getModel()).isModelLinearized()) {
6662 return ((myNPbase->STXS_ZHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6663 } else {
6665 }
6666}
6667
6668
6670: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6671{
6672 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6673 throw std::runtime_error("STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6674
6675}
6676
6678{
6679 if ((this->getModel()).isModelLinearized()) {
6680 return ((myNPbase->STXS_ZHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6681 } else {
6683 }
6684}
6685
6686
6687
6688// -----------------------------------------------------------------------------
6689// Stage 1.2
6690// -----------------------------------------------------------------------------
6691
6692STXS12_ggH_pTH200_300_Nj01::STXS12_ggH_pTH200_300_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6693: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
6694{
6695 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6696 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
6697
6698}
6699
6701{
6702 double BrHXXRatio = 1.0;
6703 if (fstate == 1){
6704 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
6705 } else if (fstate == 2){
6706 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
6707 } else if (fstate == 3){
6708 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
6709 } else if (fstate == 4){
6710 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
6711 } else {
6712 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
6713 }
6714
6715 if ((this->getModel()).isModelLinearized()) {
6716 return ((myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
6717 } else {
6718 return (myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s))*(BrHXXRatio);
6719 }
6720}
6721
6722// -----------------------------------------------------------------------------
6723
6724STXS12_ggH_pTH300_450_Nj01::STXS12_ggH_pTH300_450_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6725: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
6726{
6727 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6728 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
6729
6730}
6731
6733{
6734 double BrHXXRatio = 1.0;
6735 if (fstate == 1){
6736 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
6737 } else if (fstate == 2){
6738 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
6739 } else if (fstate == 3){
6740 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
6741 } else if (fstate == 4){
6742 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
6743 } else {
6744 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
6745 }
6746
6747 if ((this->getModel()).isModelLinearized()) {
6748 return ((myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
6749 } else {
6750 return (myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s))*(BrHXXRatio);
6751 }
6752}
6753
6754// -----------------------------------------------------------------------------
6755
6756STXS12_ggH_pTH450_650_Nj01::STXS12_ggH_pTH450_650_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6757: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
6758{
6759 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6760 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
6761
6762}
6763
6765{
6766 double BrHXXRatio = 1.0;
6767 if (fstate == 1){
6768 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
6769 } else if (fstate == 2){
6770 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
6771 } else if (fstate == 3){
6772 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
6773 } else if (fstate == 4){
6774 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
6775 } else {
6776 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
6777 }
6778
6779 if ((this->getModel()).isModelLinearized()) {
6780 return ((myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
6781 } else {
6782 return (myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s))*(BrHXXRatio);
6783 }
6784}
6785
6786// -----------------------------------------------------------------------------
6787
6788STXS12_ggH_pTH650_Inf_Nj01::STXS12_ggH_pTH650_Inf_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6789: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
6790{
6791 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6792 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
6793
6794}
6795
6797{
6798 double BrHXXRatio = 1.0;
6799 if (fstate == 1){
6800 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
6801 } else if (fstate == 2){
6802 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
6803 } else if (fstate == 3){
6804 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
6805 } else if (fstate == 4){
6806 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
6807 } else {
6808 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
6809 }
6810
6811 if ((this->getModel()).isModelLinearized()) {
6812 return ((myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
6813 } else {
6814 return (myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s))*(BrHXXRatio);
6815 }
6816}
6817
6818
6819// -----------------------------------------------------------------------------
6820
6821STXS12_ggH_pTH10_Inf_Nj0::STXS12_ggH_pTH10_Inf_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6822: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
6823{
6824 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6825 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
6826
6827}
6828
6830{
6831 //-- Production:
6832 double weight = 1.0; //If normalized to the SM
6833
6834 double muProd = myNPbase->STXS12_ggH_pTH10_Inf_Nj0(sqrt_s);
6835 double muProd1 = muProd -1.0;
6836 double muProd2 = 0.0;
6837 //-- Decay:
6838 double BrHXXRatio = 1.0;
6839 double dBrHXXRatio1 = 0.0;
6840 double dBrHXXRatio2 = 0.0;
6841
6842 if (fstate == 1){
6843 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
6844 dBrHXXRatio1 = BrHXXRatio - 1.0;
6845 dBrHXXRatio2 = 0.0;
6846 } else if (fstate == 2){
6847 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
6848 dBrHXXRatio1 = BrHXXRatio - 1.0;
6849 dBrHXXRatio2 = 0.0;
6850 } else if (fstate == 3){
6851 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
6852 dBrHXXRatio1 = BrHXXRatio - 1.0;
6853 dBrHXXRatio2 = 0.0;
6854 } else if (fstate == 4){
6855 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
6856 dBrHXXRatio1 = BrHXXRatio - 1.0;
6857 dBrHXXRatio2 = 0.0;
6858 } else {
6859 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
6860 }
6861
6862 //-- Production x Decay:
6863 if ((this->getModel()).isModelLinearized()){
6864 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
6865 } else if((this->getModel()).isModelNPquadratic()){
6866 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
6867 } else {
6868 return weight*(muProd)*(BrHXXRatio);
6869 }
6870}
6871
6872
6873
6874
6875
6876// -----------------------------------------------------------------------------
6877
6878//VM:STXS2024;
6879STXS12_ggH_pTH0_10_Nj0::STXS12_ggH_pTH0_10_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6880: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
6881{
6882 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6883 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
6884
6885}
6886
6888{
6889 //-- Production:
6890 double weight = 1.0; //If normalized to the SM
6891 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
6892 double muProd = myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s);
6893 double muProd1 = muProd -1.0;
6894 double muProd2 = 0.0;
6895
6896 //-- Decay:
6897 double BrHXXRatio = 1.0;
6898 double dBrHXXRatio1 = 0.0;
6899 double dBrHXXRatio2 = 0.0;
6900 if (fstate==0){
6901 // Use for Cross-section [pb] with no Higgs-boson decay
6902 weight = (6.6369); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
6903 } else if (fstate == 1){
6904 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
6905 dBrHXXRatio1 = BrHXXRatio - 1.0;
6906 dBrHXXRatio2 = 0.0;
6907 } else if (fstate == 2){
6908 BrHXXRatio = (myNPbase->BrHgagaRatio());
6909 dBrHXXRatio1 = BrHXXRatio - 1.0;
6910 dBrHXXRatio2 = 0.0;
6911 } else if (fstate == 3){
6912 BrHXXRatio = (myNPbase->BrHbbRatio());
6913 dBrHXXRatio1 = BrHXXRatio - 1.0;
6914 dBrHXXRatio2 = 0.0;
6915 } else if (fstate == 4){
6916 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
6917 dBrHXXRatio1 = BrHXXRatio - 1.0;
6918 dBrHXXRatio2 = 0.0;
6919 } else if (fstate == 5){
6920 BrHXXRatio = (myNPbase->BrHtautauRatio());
6921 dBrHXXRatio1 = BrHXXRatio - 1.0;
6922 dBrHXXRatio2 = 0.0;
6923 } else if (fstate == 6){
6924 BrHXXRatio = (myNPbase->BrHWWRatio());
6925 dBrHXXRatio1 = BrHXXRatio - 1.0;
6926 dBrHXXRatio2 = 0.0;
6927 } else if (fstate == 7){
6928 BrHXXRatio = (myNPbase->BrHZZRatio());
6929 dBrHXXRatio1 = BrHXXRatio - 1.0;
6930 dBrHXXRatio2 = 0.0;
6931 } else {
6932 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
6933 }
6934
6935 //-- Production x Decay:
6936 if ((this->getModel()).isModelLinearized()){
6937 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
6938 } else if((this->getModel()).isModelNPquadratic()){
6939 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
6940 } else {
6941 return weight*(muProd)*(BrHXXRatio);
6942 }
6943
6944}
6945
6946
6947
6948// -----------------------------------------------------------------------------
6949
6950//VM:STXS2024;
6951STXS12_ggH_pTH10_200_Nj0::STXS12_ggH_pTH10_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6952: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
6953{
6954 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6955 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
6956
6957}
6958
6960{
6961 //-- Production:
6962 double weight = 1.0; //If normalized to the SM
6963 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
6964 double muProd = myNPbase->STXS12_ggH_pTH10_200_Nj0(sqrt_s);
6965 double muProd1 = muProd -1.0;
6966 double muProd2 = 0.0;
6967
6968 //-- Decay:
6969 double BrHXXRatio = 1.0;
6970 double dBrHXXRatio1 = 0.0;
6971 double dBrHXXRatio2 = 0.0;
6972 if (fstate==0){
6973 // Use for Cross-section [pb] with no Higgs-boson decay
6974 weight = (20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
6975 } else if (fstate == 1){
6976 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
6977 dBrHXXRatio1 = BrHXXRatio - 1.0;
6978 dBrHXXRatio2 = 0.0;
6979 } else if (fstate == 2){
6980 BrHXXRatio = (myNPbase->BrHgagaRatio());
6981 dBrHXXRatio1 = BrHXXRatio - 1.0;
6982 dBrHXXRatio2 = 0.0;
6983 } else if (fstate == 3){
6984 BrHXXRatio = (myNPbase->BrHbbRatio());
6985 dBrHXXRatio1 = BrHXXRatio - 1.0;
6986 dBrHXXRatio2 = 0.0;
6987 } else if (fstate == 4){
6988 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
6989 dBrHXXRatio1 = BrHXXRatio - 1.0;
6990 dBrHXXRatio2 = 0.0;
6991 } else if (fstate == 5){
6992 BrHXXRatio = (myNPbase->BrHtautauRatio());
6993 dBrHXXRatio1 = BrHXXRatio - 1.0;
6994 dBrHXXRatio2 = 0.0;
6995 } else if (fstate == 6){
6996 BrHXXRatio = (myNPbase->BrHWWRatio());
6997 dBrHXXRatio1 = BrHXXRatio - 1.0;
6998 dBrHXXRatio2 = 0.0;
6999 } else if (fstate == 7){
7000 BrHXXRatio = (myNPbase->BrHZZRatio());
7001 dBrHXXRatio1 = BrHXXRatio - 1.0;
7002 dBrHXXRatio2 = 0.0;
7003 } else {
7004 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7005 }
7006
7007 //-- Production x Decay:
7008 if ((this->getModel()).isModelLinearized()){
7009 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7010 } else if((this->getModel()).isModelNPquadratic()){
7011 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7012 } else {
7013 return weight*(muProd)*(BrHXXRatio);
7014 }
7015
7016}
7017
7018
7019
7020
7021// -----------------------------------------------------------------------------
7022
7023//VM:STXS2024;
7024STXS12_ggH_pTH0_200_Nj0::STXS12_ggH_pTH0_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7025: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7026{
7027 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7028 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7029
7030}
7031
7033{
7034 //-- Production:
7035 double weight = 1.0; //If normalized to the SM
7036 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7037 double muProd = ( 6.6369*(myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s)) +
7039 /(6.6369 + 20.642);
7040 double muProd1 = muProd -1.0;
7041 double muProd2 = 0.0;
7042
7043 //-- Decay:
7044 double BrHXXRatio = 1.0;
7045 double dBrHXXRatio1 = 0.0;
7046 double dBrHXXRatio2 = 0.0;
7047 if (fstate==0){
7048 // Use for Cross-section [pb] with no Higgs-boson decay
7049 weight = (6.6369 + 20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7050 } else if (fstate == 1){
7051 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7052 dBrHXXRatio1 = BrHXXRatio - 1.0;
7053 dBrHXXRatio2 = 0.0;
7054 } else if (fstate == 2){
7055 BrHXXRatio = (myNPbase->BrHgagaRatio());
7056 dBrHXXRatio1 = BrHXXRatio - 1.0;
7057 dBrHXXRatio2 = 0.0;
7058 } else if (fstate == 3){
7059 BrHXXRatio = (myNPbase->BrHbbRatio());
7060 dBrHXXRatio1 = BrHXXRatio - 1.0;
7061 dBrHXXRatio2 = 0.0;
7062 } else if (fstate == 4){
7063 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7064 dBrHXXRatio1 = BrHXXRatio - 1.0;
7065 dBrHXXRatio2 = 0.0;
7066 } else if (fstate == 5){
7067 BrHXXRatio = (myNPbase->BrHtautauRatio());
7068 dBrHXXRatio1 = BrHXXRatio - 1.0;
7069 dBrHXXRatio2 = 0.0;
7070 } else if (fstate == 6){
7071 BrHXXRatio = (myNPbase->BrHWWRatio());
7072 dBrHXXRatio1 = BrHXXRatio - 1.0;
7073 dBrHXXRatio2 = 0.0;
7074 } else if (fstate == 7){
7075 BrHXXRatio = (myNPbase->BrHZZRatio());
7076 dBrHXXRatio1 = BrHXXRatio - 1.0;
7077 dBrHXXRatio2 = 0.0;
7078 } else {
7079 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7080 }
7081
7082 //-- Production x Decay:
7083 if ((this->getModel()).isModelLinearized()){
7084 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7085 } else if((this->getModel()).isModelNPquadratic()){
7086 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7087 } else {
7088 return weight*(muProd)*(BrHXXRatio);
7089 }
7090
7091}
7092
7093
7094
7095
7096// -----------------------------------------------------------------------------
7097
7098//VM:STXS2024;
7099STXS12_ggH_mjj0_350_pTH0_60_Nj1::STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7100: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7101{
7102 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7103 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7104
7105}
7106
7108{
7109 //-- Production:
7110 double weight = 1.0; //If normalized to the SM
7111 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7112
7113 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj1(sqrt_s)) );
7114 double muProd1 = muProd -1.0;
7115 double muProd2 = 0.0;
7116
7117 //-- Decay:
7118 double BrHXXRatio = 1.0;
7119 double dBrHXXRatio1 = 0.0;
7120 double dBrHXXRatio2 = 0.0;
7121 if (fstate==0){
7122 // Use for Cross-section [pb] with no Higgs-boson decay
7123 weight = (1.); //NOT in Ref: https://www.hepdata.net/record/ins2104706 Figure7. Missing SM prediction!!!
7124 } else if (fstate == 1){
7125 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7126 dBrHXXRatio1 = BrHXXRatio - 1.0;
7127 dBrHXXRatio2 = 0.0;
7128 } else if (fstate == 2){
7129 BrHXXRatio = (myNPbase->BrHgagaRatio());
7130 dBrHXXRatio1 = BrHXXRatio - 1.0;
7131 dBrHXXRatio2 = 0.0;
7132 } else if (fstate == 3){
7133 BrHXXRatio = (myNPbase->BrHbbRatio());
7134 dBrHXXRatio1 = BrHXXRatio - 1.0;
7135 dBrHXXRatio2 = 0.0;
7136 } else if (fstate == 4){
7137 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7138 dBrHXXRatio1 = BrHXXRatio - 1.0;
7139 dBrHXXRatio2 = 0.0;
7140 } else if (fstate == 5){
7141 BrHXXRatio = (myNPbase->BrHtautauRatio());
7142 dBrHXXRatio1 = BrHXXRatio - 1.0;
7143 dBrHXXRatio2 = 0.0;
7144 } else if (fstate == 6){
7145 BrHXXRatio = (myNPbase->BrHWWRatio());
7146 dBrHXXRatio1 = BrHXXRatio - 1.0;
7147 dBrHXXRatio2 = 0.0;
7148 } else if (fstate == 7){
7149 BrHXXRatio = (myNPbase->BrHZZRatio());
7150 dBrHXXRatio1 = BrHXXRatio - 1.0;
7151 dBrHXXRatio2 = 0.0;
7152 } else {
7153 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7154 }
7155
7156 //-- Production x Decay:
7157 if ((this->getModel()).isModelLinearized()){
7158 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7159 } else if((this->getModel()).isModelNPquadratic()){
7160 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7161 } else {
7162 return weight*(muProd)*(BrHXXRatio);
7163 }
7164
7165}
7166
7167
7168
7169
7170
7171
7172
7173// -----------------------------------------------------------------------------
7174
7175//AG:STXS2024
7176STXS12_ggH_pTH0_60_Nj1::STXS12_ggH_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7177: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7178{
7179 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7180 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7181
7182}
7183
7185{
7186 //-- Production:
7187 double weight = 1.0; //If normalized to the SM
7188 double muProd = myNPbase->STXS12_ggH_pTH0_60_Nj1(sqrt_s);
7189 double muProd1 = muProd -1.0;
7190 double muProd2 = 0.0;
7191
7192 //-- Decay:
7193 double BrHXXRatio = 1.0;
7194 double dBrHXXRatio1 = 0.0;
7195 double dBrHXXRatio2 = 0.0;
7196 if (fstate==0){
7197 // Use for Cross-section [pb] with no Higgs-boson decay
7198 weight = 6.50045; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7199 } else if (fstate == 1){
7200 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7201 dBrHXXRatio1 = BrHXXRatio - 1.0;
7202 dBrHXXRatio2 = 0.0;
7203 } else if (fstate == 2){
7204 BrHXXRatio = (myNPbase->BrHgagaRatio());
7205 dBrHXXRatio1 = BrHXXRatio - 1.0;
7206 dBrHXXRatio2 = 0.0;
7207 } else if (fstate == 3){
7208 BrHXXRatio = (myNPbase->BrHbbRatio());
7209 dBrHXXRatio1 = BrHXXRatio - 1.0;
7210 dBrHXXRatio2 = 0.0;
7211 } else if (fstate == 4){
7212 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7213 dBrHXXRatio1 = BrHXXRatio - 1.0;
7214 dBrHXXRatio2 = 0.0;
7215 } else if (fstate == 5){
7216 BrHXXRatio = (myNPbase->BrHtautauRatio());
7217 dBrHXXRatio1 = BrHXXRatio - 1.0;
7218 dBrHXXRatio2 = 0.0;
7219 } else if (fstate == 6){
7220 BrHXXRatio = (myNPbase->BrHWWRatio());
7221 dBrHXXRatio1 = BrHXXRatio - 1.0;
7222 dBrHXXRatio2 = 0.0;
7223 } else if (fstate == 7){
7224 BrHXXRatio = (myNPbase->BrHZZRatio());
7225 dBrHXXRatio1 = BrHXXRatio - 1.0;
7226 dBrHXXRatio2 = 0.0;
7227 } else {
7228 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7229 }
7230
7231 //-- Production x Decay:
7232 if ((this->getModel()).isModelLinearized()){
7233 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7234 } else if((this->getModel()).isModelNPquadratic()){
7235 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7236 } else {
7237 return weight*(muProd)*(BrHXXRatio);
7238 }
7239
7240}
7241
7242// -----------------------------------------------------------------------------
7243
7244//AG:STXS2024
7245STXS12_ggH_pTH60_120_Nj1::STXS12_ggH_pTH60_120_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7246: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7247{
7248 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7249 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7250
7251}
7252
7254{
7255 //-- Production:
7256 double weight = 1.0; //If normalized to the SM
7257 double muProd = myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s);
7258 double muProd1 = muProd -1.0;
7259 double muProd2 = 0.0;
7260
7261 //-- Decay:
7262 double BrHXXRatio = 1.0;
7263 double dBrHXXRatio1 = 0.0;
7264 double dBrHXXRatio2 = 0.0;
7265 if (fstate==0){
7266 // Use for Cross-section [pb] with no Higgs-boson decay
7267 weight = 4.50294; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7268 } else if (fstate == 1){
7269 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7270 dBrHXXRatio1 = BrHXXRatio - 1.0;
7271 dBrHXXRatio2 = 0.0;
7272 } else if (fstate == 2){
7273 BrHXXRatio = (myNPbase->BrHgagaRatio());
7274 dBrHXXRatio1 = BrHXXRatio - 1.0;
7275 dBrHXXRatio2 = 0.0;
7276 } else if (fstate == 3){
7277 BrHXXRatio = (myNPbase->BrHbbRatio());
7278 dBrHXXRatio1 = BrHXXRatio - 1.0;
7279 dBrHXXRatio2 = 0.0;
7280 } else if (fstate == 4){
7281 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7282 dBrHXXRatio1 = BrHXXRatio - 1.0;
7283 dBrHXXRatio2 = 0.0;
7284 } else if (fstate == 5){
7285 BrHXXRatio = (myNPbase->BrHtautauRatio());
7286 dBrHXXRatio1 = BrHXXRatio - 1.0;
7287 dBrHXXRatio2 = 0.0;
7288 } else if (fstate == 6){
7289 BrHXXRatio = (myNPbase->BrHWWRatio());
7290 dBrHXXRatio1 = BrHXXRatio - 1.0;
7291 dBrHXXRatio2 = 0.0;
7292 } else if (fstate == 7){
7293 BrHXXRatio = (myNPbase->BrHZZRatio());
7294 dBrHXXRatio1 = BrHXXRatio - 1.0;
7295 dBrHXXRatio2 = 0.0;
7296 } else {
7297 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7298 }
7299
7300 //-- Production x Decay:
7301 if ((this->getModel()).isModelLinearized()){
7302 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7303 } else if((this->getModel()).isModelNPquadratic()){
7304 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7305 } else {
7306 return weight*(muProd)*(BrHXXRatio);
7307 }
7308
7309}
7310
7311// -----------------------------------------------------------------------------
7312
7313//AG:STXS2024
7314STXS12_ggH_pTH120_200_Nj1::STXS12_ggH_pTH120_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7315: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7316{
7317 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7318 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7319
7320}
7321
7323{
7324 //-- Production:
7325 double weight = 1.0; //If normalized to the SM
7326 double muProd = myNPbase->STXS12_ggH_pTH120_200_Nj1(sqrt_s);
7327 double muProd1 = muProd -1.0;
7328 double muProd2 = 0.0;
7329
7330 //-- Decay:
7331 double BrHXXRatio = 1.0;
7332 double dBrHXXRatio1 = 0.0;
7333 double dBrHXXRatio2 = 0.0;
7334 if (fstate==0){
7335 // Use for Cross-section [pb] with no Higgs-boson decay
7336 weight = 0.74712; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7337 } else if (fstate == 1){
7338 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7339 dBrHXXRatio1 = BrHXXRatio - 1.0;
7340 dBrHXXRatio2 = 0.0;
7341 } else if (fstate == 2){
7342 BrHXXRatio = (myNPbase->BrHgagaRatio());
7343 dBrHXXRatio1 = BrHXXRatio - 1.0;
7344 dBrHXXRatio2 = 0.0;
7345 } else if (fstate == 3){
7346 BrHXXRatio = (myNPbase->BrHbbRatio());
7347 dBrHXXRatio1 = BrHXXRatio - 1.0;
7348 dBrHXXRatio2 = 0.0;
7349 } else if (fstate == 4){
7350 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7351 dBrHXXRatio1 = BrHXXRatio - 1.0;
7352 dBrHXXRatio2 = 0.0;
7353 } else if (fstate == 5){
7354 BrHXXRatio = (myNPbase->BrHtautauRatio());
7355 dBrHXXRatio1 = BrHXXRatio - 1.0;
7356 dBrHXXRatio2 = 0.0;
7357 } else if (fstate == 6){
7358 BrHXXRatio = (myNPbase->BrHWWRatio());
7359 dBrHXXRatio1 = BrHXXRatio - 1.0;
7360 dBrHXXRatio2 = 0.0;
7361 } else if (fstate == 7){
7362 BrHXXRatio = (myNPbase->BrHZZRatio());
7363 dBrHXXRatio1 = BrHXXRatio - 1.0;
7364 dBrHXXRatio2 = 0.0;
7365 } else {
7366 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7367 }
7368
7369 //-- Production x Decay:
7370 if ((this->getModel()).isModelLinearized()){
7371 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7372 } else if((this->getModel()).isModelNPquadratic()){
7373 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7374 } else {
7375 return weight*(muProd)*(BrHXXRatio);
7376 }
7377
7378}
7379
7380// -----------------------------------------------------------------------------
7381
7382STXS12_ggH_mjj0_350_pTH0_60_Nj2::STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7383: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7384{
7385 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7386 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7387
7388}
7389
7391{
7392 double BrHXXRatio = 1.0;
7393 if (fstate == 1){
7394 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7395 } else if (fstate == 2){
7396 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7397 } else if (fstate == 3){
7398 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7399 } else if (fstate == 4){
7400 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7401 } else {
7402 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7403 }
7404
7405 if ((this->getModel()).isModelLinearized()) {
7406 return ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7407 } else {
7408 return (myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s))*(BrHXXRatio);
7409 }
7410}
7411
7412// -----------------------------------------------------------------------------
7413
7414STXS12_ggH_mjj0_350_pTH60_120_Nj2::STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7415: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7416{
7417 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7418 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
7419
7420}
7421
7423{
7424 double BrHXXRatio = 1.0;
7425 if (fstate == 1){
7426 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7427 } else if (fstate == 2){
7428 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7429 } else if (fstate == 3){
7430 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7431 } else if (fstate == 4){
7432 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7433 } else {
7434 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
7435 }
7436
7437 if ((this->getModel()).isModelLinearized()) {
7438 return ((myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7439 } else {
7440 return (myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s))*(BrHXXRatio);
7441 }
7442}
7443
7444
7445
7446
7447
7448// -----------------------------------------------------------------------------
7449
7450//VM:STXS2024;
7451STXS12_ggH_mjj0_350_pTH0_120_Nj2::STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7452: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7453{
7454 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7455 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
7456
7457}
7458
7460{
7461 //-- Production:
7462 double weight = 1.0; //If normalized to the SM
7463 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7464 //We should weight each xsection with the SM prediction. We need to check
7465 //this values, nevertheless, the difference between the two parametrisations
7466 //is extremely small (way beyond our current precision)
7467 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) +
7469 /(2.);
7470 double muProd1 = muProd -1.0;
7471 double muProd2 = 0.0;
7472
7473 //-- Decay:
7474 double BrHXXRatio = 1.0;
7475 double dBrHXXRatio1 = 0.0;
7476 double dBrHXXRatio2 = 0.0;
7477 if (fstate==0){
7478 // Use for Cross-section [pb] with no Higgs-boson decay
7479 weight = (2.9636); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7480 } else if (fstate == 1){
7481 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7482 dBrHXXRatio1 = BrHXXRatio - 1.0;
7483 dBrHXXRatio2 = 0.0;
7484 } else if (fstate == 2){
7485 BrHXXRatio = (myNPbase->BrHgagaRatio());
7486 dBrHXXRatio1 = BrHXXRatio - 1.0;
7487 dBrHXXRatio2 = 0.0;
7488 } else if (fstate == 3){
7489 BrHXXRatio = (myNPbase->BrHbbRatio());
7490 dBrHXXRatio1 = BrHXXRatio - 1.0;
7491 dBrHXXRatio2 = 0.0;
7492 } else if (fstate == 4){
7493 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7494 dBrHXXRatio1 = BrHXXRatio - 1.0;
7495 dBrHXXRatio2 = 0.0;
7496 } else if (fstate == 5){
7497 BrHXXRatio = (myNPbase->BrHtautauRatio());
7498 dBrHXXRatio1 = BrHXXRatio - 1.0;
7499 dBrHXXRatio2 = 0.0;
7500 } else if (fstate == 6){
7501 BrHXXRatio = (myNPbase->BrHWWRatio());
7502 dBrHXXRatio1 = BrHXXRatio - 1.0;
7503 dBrHXXRatio2 = 0.0;
7504 } else if (fstate == 7){
7505 BrHXXRatio = (myNPbase->BrHZZRatio());
7506 dBrHXXRatio1 = BrHXXRatio - 1.0;
7507 dBrHXXRatio2 = 0.0;
7508 } else {
7509 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
7510 }
7511
7512 //-- Production x Decay:
7513 if ((this->getModel()).isModelLinearized()){
7514 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7515 } else if((this->getModel()).isModelNPquadratic()){
7516 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7517 } else {
7518 return weight*(muProd)*(BrHXXRatio);
7519 }
7520
7521}
7522
7523
7524
7525
7526// -----------------------------------------------------------------------------
7527
7528//AG:STXS2024
7529STXS12_ggH_mjj0_350_pTH120_200_Nj2::STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7530: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7531{
7532 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7533 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
7534
7535}
7536
7538{
7539 //-- Production:
7540 double weight = 1.0; //If normalized to the SM
7542 double muProd1 = muProd -1.0;
7543 double muProd2 = 0.0;
7544
7545 //-- Decay:
7546 double BrHXXRatio = 1.0;
7547 double dBrHXXRatio1 = 0.0;
7548 double dBrHXXRatio2 = 0.0;
7549 if (fstate==0){
7550 // Use for Cross-section [pb] with no Higgs-boson decay
7551 weight = 0.94325; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7552 } else if (fstate == 1){
7553 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7554 dBrHXXRatio1 = BrHXXRatio - 1.0;
7555 dBrHXXRatio2 = 0.0;
7556 } else if (fstate == 2){
7557 BrHXXRatio = (myNPbase->BrHgagaRatio());
7558 dBrHXXRatio1 = BrHXXRatio - 1.0;
7559 dBrHXXRatio2 = 0.0;
7560 } else if (fstate == 3){
7561 BrHXXRatio = (myNPbase->BrHbbRatio());
7562 dBrHXXRatio1 = BrHXXRatio - 1.0;
7563 dBrHXXRatio2 = 0.0;
7564 } else if (fstate == 4){
7565 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7566 dBrHXXRatio1 = BrHXXRatio - 1.0;
7567 dBrHXXRatio2 = 0.0;
7568 } else if (fstate == 5){
7569 BrHXXRatio = (myNPbase->BrHtautauRatio());
7570 dBrHXXRatio1 = BrHXXRatio - 1.0;
7571 dBrHXXRatio2 = 0.0;
7572 }else {
7573 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
7574 }
7575
7576 //-- Production x Decay:
7577 if ((this->getModel()).isModelLinearized()){
7578 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7579 } else if((this->getModel()).isModelNPquadratic()){
7580 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7581 } else {
7582 return weight*(muProd)*(BrHXXRatio);
7583 }
7584
7585}
7586
7587
7588
7589
7590//VM:STXS2024;
7591STXS12_ggH_mjj350_Inf_pTH0_200_Nj2::STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7592: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7593{
7594 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7595 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
7596
7597}
7598
7600{
7601 //-- Production:
7602 double weight = 1.0; //If normalized to the SM
7603 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7604 //We should weight each xsection with the SM prediction. We need to check
7605 //this values, nevertheless, the difference between the two parametrisations
7606 //is extremely small (way beyond our current precision)
7609 /(2.);
7610 double muProd1 = muProd -1.0;
7611 double muProd2 = 0.0;
7612
7613 //-- Decay:
7614 double BrHXXRatio = 1.0;
7615 double dBrHXXRatio1 = 0.0;
7616 double dBrHXXRatio2 = 0.0;
7617 if (fstate==0){
7618 // Use for Cross-section [pb] with no Higgs-boson decay
7619 weight = (0.92136); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7620 } else if (fstate == 1){
7621 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7622 dBrHXXRatio1 = BrHXXRatio - 1.0;
7623 dBrHXXRatio2 = 0.0;
7624 } else if (fstate == 2){
7625 BrHXXRatio = (myNPbase->BrHgagaRatio());
7626 dBrHXXRatio1 = BrHXXRatio - 1.0;
7627 dBrHXXRatio2 = 0.0;
7628 } else if (fstate == 3){
7629 BrHXXRatio = (myNPbase->BrHbbRatio());
7630 dBrHXXRatio1 = BrHXXRatio - 1.0;
7631 dBrHXXRatio2 = 0.0;
7632 } else if (fstate == 4){
7633 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7634 dBrHXXRatio1 = BrHXXRatio - 1.0;
7635 dBrHXXRatio2 = 0.0;
7636 } else if (fstate == 5){
7637 BrHXXRatio = (myNPbase->BrHtautauRatio());
7638 dBrHXXRatio1 = BrHXXRatio - 1.0;
7639 dBrHXXRatio2 = 0.0;
7640 } else if (fstate == 6){
7641 BrHXXRatio = (myNPbase->BrHWWRatio());
7642 dBrHXXRatio1 = BrHXXRatio - 1.0;
7643 dBrHXXRatio2 = 0.0;
7644 } else if (fstate == 7){
7645 BrHXXRatio = (myNPbase->BrHZZRatio());
7646 dBrHXXRatio1 = BrHXXRatio - 1.0;
7647 dBrHXXRatio2 = 0.0;
7648 } else {
7649 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
7650 }
7651
7652 //-- Production x Decay:
7653 if ((this->getModel()).isModelLinearized()){
7654 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7655 } else if((this->getModel()).isModelNPquadratic()){
7656 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7657 } else {
7658 return weight*(muProd)*(BrHXXRatio);
7659 }
7660
7661}
7662
7663
7664// -----------------------------------------------------------------------------
7665
7667: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7668{
7669 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7670 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
7671
7672}
7673
7675{
7676 double BrHXXRatio = 1.0;
7677 if (fstate == 1){
7678 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7679 } else if (fstate == 2){
7680 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7681 } else if (fstate == 3){
7682 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7683 } else if (fstate == 4){
7684 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7685 } else {
7686 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
7687 }
7688
7689 if ((this->getModel()).isModelLinearized()) {
7690 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7691 } else {
7693 }
7694}
7695
7696// -----------------------------------------------------------------------------
7697
7699: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7700{
7701
7702 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7703 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
7704
7705}
7706
7708{
7709 double BrHXXRatio = 1.0;
7710 if (fstate == 1){
7711 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7712 } else if (fstate == 2){
7713 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7714 } else if (fstate == 3){
7715 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7716 } else if (fstate == 4){
7717 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7718 } else {
7719 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
7720 }
7721
7722 if ((this->getModel()).isModelLinearized()) {
7723 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7724 } else {
7726 }
7727}
7728
7729// -----------------------------------------------------------------------------
7730
7732: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7733{
7734 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7735 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
7736
7737}
7738
7740{
7741 double BrHXXRatio = 1.0;
7742 if (fstate == 1){
7743 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7744 } else if (fstate == 2){
7745 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7746 } else if (fstate == 3){
7747 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7748 } else if (fstate == 4){
7749 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7750 } else {
7751 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
7752 }
7753
7754 if ((this->getModel()).isModelLinearized()) {
7755 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7756 } else {
7758 }
7759}
7760
7761// -----------------------------------------------------------------------------
7762
7764: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7765{
7766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7767 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
7768
7769}
7770
7772{
7773 double BrHXXRatio = 1.0;
7774 if (fstate == 1){
7775 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7776 } else if (fstate == 2){
7777 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7778 } else if (fstate == 3){
7779 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7780 } else if (fstate == 4){
7781 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7782 } else {
7783 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
7784 }
7785
7786 if ((this->getModel()).isModelLinearized()) {
7787 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7788 } else {
7790 }
7791}
7792
7793
7794
7795
7796
7797// -----------------------------------------------------------------------------
7798
7799//VM:STXS2024;
7800STXS12_ggH_pTH0_200_Nj2::STXS12_ggH_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7801: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7802{
7803 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7804 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
7805
7806}
7807
7809{
7810
7811
7812
7813 //-- Production:
7814 double weight = 1.0; //If normalized to the SM
7815 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7816 //VM: In the reference above we have the SM predictions for less bins. Angelica should have
7817 //the ones for Madgraph and we could use those. In any case the parametrisation is very stable
7818 //we give the same weight to the bins for which we don't have the SM prediction (for the moment)!
7819 //The possible error that we could be introducing here is way below our precision!
7820 double muProd = (
7824 )/(2.9636+0.94321+0.87751);
7825 double muProd1 = muProd -1.0;
7826 double muProd2 = 0.0;
7827
7828 //-- Decay:
7829 double BrHXXRatio = 1.0;
7830 double dBrHXXRatio1 = 0.0;
7831 double dBrHXXRatio2 = 0.0;
7832 if (fstate==0){
7833 // Use for Cross-section [pb] with no Higgs-boson decay
7834 weight = (2.9636+0.94321+0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7835 } else if (fstate == 1){
7836 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7837 dBrHXXRatio1 = BrHXXRatio - 1.0;
7838 dBrHXXRatio2 = 0.0;
7839 } else if (fstate == 2){
7840 BrHXXRatio = (myNPbase->BrHgagaRatio());
7841 dBrHXXRatio1 = BrHXXRatio - 1.0;
7842 dBrHXXRatio2 = 0.0;
7843 } else if (fstate == 3){
7844 BrHXXRatio = (myNPbase->BrHbbRatio());
7845 dBrHXXRatio1 = BrHXXRatio - 1.0;
7846 dBrHXXRatio2 = 0.0;
7847 } else if (fstate == 4){
7848 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7849 dBrHXXRatio1 = BrHXXRatio - 1.0;
7850 dBrHXXRatio2 = 0.0;
7851 } else if (fstate == 5){
7852 BrHXXRatio = (myNPbase->BrHtautauRatio());
7853 dBrHXXRatio1 = BrHXXRatio - 1.0;
7854 dBrHXXRatio2 = 0.0;
7855 } else if (fstate == 6){
7856 BrHXXRatio = (myNPbase->BrHWWRatio());
7857 dBrHXXRatio1 = BrHXXRatio - 1.0;
7858 dBrHXXRatio2 = 0.0;
7859 } else if (fstate == 7){
7860 BrHXXRatio = (myNPbase->BrHZZRatio());
7861 dBrHXXRatio1 = BrHXXRatio - 1.0;
7862 dBrHXXRatio2 = 0.0;
7863 } else {
7864 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
7865 }
7866
7867 //-- Production x Decay:
7868 if ((this->getModel()).isModelLinearized()){
7869 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7870 } else if((this->getModel()).isModelNPquadratic()){
7871 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7872 } else {
7873 return weight*(muProd)*(BrHXXRatio);
7874 }
7875
7876}
7877
7878
7879
7880
7881
7882
7883
7884// -----------------------------------------------------------------------------
7885
7886
7887//VM:STXS2024;
7888STXS12_ggH_pTH200_Inf::STXS12_ggH_pTH200_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7889: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7890{
7891 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7892 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
7893
7894}
7895
7897{
7898 //-- Production:
7899 double weight = 1.0; //If normalized to the SM
7900 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7901 double muProd = ( 0.45825*(myNPbase->STXS12_ggH_pTH200_300(sqrt_s)) +
7904 /(0.45825 + 0.10632 + 0.017974);
7905 double muProd1 = muProd -1.0;
7906 double muProd2 = 0.0;
7907
7908 //-- Decay:
7909 double BrHXXRatio = 1.0;
7910 double dBrHXXRatio1 = 0.0;
7911 double dBrHXXRatio2 = 0.0;
7912 if (fstate==0){
7913 // Use for Cross-section [pb] with no Higgs-boson decay
7914 weight = (0.45825 + 0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7915 } else if (fstate == 1){
7916 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7917 dBrHXXRatio1 = BrHXXRatio - 1.0;
7918 dBrHXXRatio2 = 0.0;
7919 } else if (fstate == 2){
7920 BrHXXRatio = (myNPbase->BrHgagaRatio());
7921 dBrHXXRatio1 = BrHXXRatio - 1.0;
7922 dBrHXXRatio2 = 0.0;
7923 } else if (fstate == 3){
7924 BrHXXRatio = (myNPbase->BrHbbRatio());
7925 dBrHXXRatio1 = BrHXXRatio - 1.0;
7926 dBrHXXRatio2 = 0.0;
7927 } else if (fstate == 4){
7928 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7929 dBrHXXRatio1 = BrHXXRatio - 1.0;
7930 dBrHXXRatio2 = 0.0;
7931 } else if (fstate == 5){
7932 BrHXXRatio = (myNPbase->BrHtautauRatio());
7933 dBrHXXRatio1 = BrHXXRatio - 1.0;
7934 dBrHXXRatio2 = 0.0;
7935 } else if (fstate == 6){
7936 BrHXXRatio = (myNPbase->BrHWWRatio());
7937 dBrHXXRatio1 = BrHXXRatio - 1.0;
7938 dBrHXXRatio2 = 0.0;
7939 } else if (fstate == 7){
7940 BrHXXRatio = (myNPbase->BrHZZRatio());
7941 dBrHXXRatio1 = BrHXXRatio - 1.0;
7942 dBrHXXRatio2 = 0.0;
7943 } else {
7944 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
7945 }
7946
7947 //-- Production x Decay:
7948 if ((this->getModel()).isModelLinearized()){
7949 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7950 } else if((this->getModel()).isModelNPquadratic()){
7951 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7952 } else {
7953 return weight*(muProd)*(BrHXXRatio);
7954 }
7955
7956}
7957
7958
7959
7960
7961// -----------------------------------------------------------------------------
7962
7963
7964//VM:STXS2024;
7965STXS12_ggH_pTH300_Inf::STXS12_ggH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7966: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7967{
7968 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7969 throw std::runtime_error("STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
7970
7971}
7972
7974{
7975 //-- Production:
7976 double weight = 1.0; //If normalized to the SM
7977 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7978 double muProd = (0.10632*(myNPbase->STXS12_ggH_pTH300_450(sqrt_s)) +
7980 /(0.10632 + 0.017974);
7981 double muProd1 = muProd -1.0;
7982 double muProd2 = 0.0;
7983
7984 //-- Decay:
7985 double BrHXXRatio = 1.0;
7986 double dBrHXXRatio1 = 0.0;
7987 double dBrHXXRatio2 = 0.0;
7988 if (fstate==0){
7989 // Use for Cross-section [pb] with no Higgs-boson decay
7990 weight = (0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7991 } else if (fstate == 1){
7992 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7993 dBrHXXRatio1 = BrHXXRatio - 1.0;
7994 dBrHXXRatio2 = 0.0;
7995 } else if (fstate == 2){
7996 BrHXXRatio = (myNPbase->BrHgagaRatio());
7997 dBrHXXRatio1 = BrHXXRatio - 1.0;
7998 dBrHXXRatio2 = 0.0;
7999 } else if (fstate == 3){
8000 BrHXXRatio = (myNPbase->BrHbbRatio());
8001 dBrHXXRatio1 = BrHXXRatio - 1.0;
8002 dBrHXXRatio2 = 0.0;
8003 } else if (fstate == 4){
8004 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8005 dBrHXXRatio1 = BrHXXRatio - 1.0;
8006 dBrHXXRatio2 = 0.0;
8007 } else if (fstate == 5){
8008 BrHXXRatio = (myNPbase->BrHtautauRatio());
8009 dBrHXXRatio1 = BrHXXRatio - 1.0;
8010 dBrHXXRatio2 = 0.0;
8011 } else if (fstate == 6){
8012 BrHXXRatio = (myNPbase->BrHWWRatio());
8013 dBrHXXRatio1 = BrHXXRatio - 1.0;
8014 dBrHXXRatio2 = 0.0;
8015 } else if (fstate == 7){
8016 BrHXXRatio = (myNPbase->BrHZZRatio());
8017 dBrHXXRatio1 = BrHXXRatio - 1.0;
8018 dBrHXXRatio2 = 0.0;
8019 } else {
8020 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8021 }
8022
8023 //-- Production x Decay:
8024 if ((this->getModel()).isModelLinearized()){
8025 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8026 } else if((this->getModel()).isModelNPquadratic()){
8027 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8028 } else {
8029 return weight*(muProd)*(BrHXXRatio);
8030 }
8031
8032}
8033
8034
8035// -----------------------------------------------------------------------------
8036
8037
8038//VM:STXS2024;
8039STXS12_ggH_pTH200_300::STXS12_ggH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8040: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8041{
8042 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8043 throw std::runtime_error("STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8044
8045}
8046
8048{
8049 //-- Production:
8050 double weight = 1.0; //If normalized to the SM
8051 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8052 double muProd = myNPbase->STXS12_ggH_pTH200_300(sqrt_s);
8053 double muProd1 = muProd -1.0;
8054 double muProd2 = 0.0;
8055
8056 //-- Decay:
8057 double BrHXXRatio = 1.0;
8058 double dBrHXXRatio1 = 0.0;
8059 double dBrHXXRatio2 = 0.0;
8060 if (fstate==0){
8061 // Use for Cross-section [pb] with no Higgs-boson decay
8062 weight = (0.45825 ); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8063 } else if (fstate == 1){
8064 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8065 dBrHXXRatio1 = BrHXXRatio - 1.0;
8066 dBrHXXRatio2 = 0.0;
8067 } else if (fstate == 2){
8068 BrHXXRatio = (myNPbase->BrHgagaRatio());
8069 dBrHXXRatio1 = BrHXXRatio - 1.0;
8070 dBrHXXRatio2 = 0.0;
8071 } else if (fstate == 3){
8072 BrHXXRatio = (myNPbase->BrHbbRatio());
8073 dBrHXXRatio1 = BrHXXRatio - 1.0;
8074 dBrHXXRatio2 = 0.0;
8075 } else if (fstate == 4){
8076 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8077 dBrHXXRatio1 = BrHXXRatio - 1.0;
8078 dBrHXXRatio2 = 0.0;
8079 } else if (fstate == 5){
8080 BrHXXRatio = (myNPbase->BrHtautauRatio());
8081 dBrHXXRatio1 = BrHXXRatio - 1.0;
8082 dBrHXXRatio2 = 0.0;
8083 } else if (fstate == 6){
8084 BrHXXRatio = (myNPbase->BrHWWRatio());
8085 dBrHXXRatio1 = BrHXXRatio - 1.0;
8086 dBrHXXRatio2 = 0.0;
8087 } else if (fstate == 7){
8088 BrHXXRatio = (myNPbase->BrHZZRatio());
8089 dBrHXXRatio1 = BrHXXRatio - 1.0;
8090 dBrHXXRatio2 = 0.0;
8091 } else {
8092 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8093 }
8094
8095 //-- Production x Decay:
8096 if ((this->getModel()).isModelLinearized()){
8097 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8098 } else if((this->getModel()).isModelNPquadratic()){
8099 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8100 } else {
8101 return weight*(muProd)*(BrHXXRatio);
8102 }
8103
8104}
8105
8106
8107
8108// -----------------------------------------------------------------------------
8109
8110
8111//VM:STXS2024;
8112STXS12_ggH_pTH300_450::STXS12_ggH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8113: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8114{
8115 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8116 throw std::runtime_error("STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8117
8118}
8119
8121{
8122 //-- Production:
8123 double weight = 1.0; //If normalized to the SM
8124 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8125 double muProd = myNPbase->STXS12_ggH_pTH300_450(sqrt_s);
8126 double muProd1 = muProd -1.0;
8127 double muProd2 = 0.0;
8128
8129 //-- Decay:
8130 double BrHXXRatio = 1.0;
8131 double dBrHXXRatio1 = 0.0;
8132 double dBrHXXRatio2 = 0.0;
8133 if (fstate==0){
8134 // Use for Cross-section [pb] with no Higgs-boson decay
8135 weight = 0.10632; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8136 } else if (fstate == 1){
8137 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8138 dBrHXXRatio1 = BrHXXRatio - 1.0;
8139 dBrHXXRatio2 = 0.0;
8140 } else if (fstate == 2){
8141 BrHXXRatio = (myNPbase->BrHgagaRatio());
8142 dBrHXXRatio1 = BrHXXRatio - 1.0;
8143 dBrHXXRatio2 = 0.0;
8144 } else if (fstate == 3){
8145 BrHXXRatio = (myNPbase->BrHbbRatio());
8146 dBrHXXRatio1 = BrHXXRatio - 1.0;
8147 dBrHXXRatio2 = 0.0;
8148 } else if (fstate == 4){
8149 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8150 dBrHXXRatio1 = BrHXXRatio - 1.0;
8151 dBrHXXRatio2 = 0.0;
8152 } else if (fstate == 5){
8153 BrHXXRatio = (myNPbase->BrHtautauRatio());
8154 dBrHXXRatio1 = BrHXXRatio - 1.0;
8155 dBrHXXRatio2 = 0.0;
8156 } else if (fstate == 6){
8157 BrHXXRatio = (myNPbase->BrHWWRatio());
8158 dBrHXXRatio1 = BrHXXRatio - 1.0;
8159 dBrHXXRatio2 = 0.0;
8160 } else if (fstate == 7){
8161 BrHXXRatio = (myNPbase->BrHZZRatio());
8162 dBrHXXRatio1 = BrHXXRatio - 1.0;
8163 dBrHXXRatio2 = 0.0;
8164 } else {
8165 throw std::runtime_error("STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8166 }
8167
8168 //-- Production x Decay:
8169 if ((this->getModel()).isModelLinearized()){
8170 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8171 } else if((this->getModel()).isModelNPquadratic()){
8172 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8173 } else {
8174 return weight*(muProd)*(BrHXXRatio);
8175 }
8176
8177}
8178
8179
8180
8181
8182// -----------------------------------------------------------------------------
8183
8184
8185//VM:STXS2024;
8186STXS12_ggH_pTH450_650::STXS12_ggH_pTH450_650(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8187: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8188{
8189 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8190 throw std::runtime_error("STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8191
8192}
8193
8195{
8196 //-- Production:
8197 double weight = 1.0; //If normalized to the SM
8198 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8199 double muProd = myNPbase->STXS12_ggH_pTH450_650(sqrt_s);
8200 double muProd1 = muProd -1.0;
8201 double muProd2 = 0.0;
8202
8203 //-- Decay:
8204 double BrHXXRatio = 1.0;
8205 double dBrHXXRatio1 = 0.0;
8206 double dBrHXXRatio2 = 0.0;
8207 if (fstate==0){
8208 // Use for Cross-section [pb] with no Higgs-boson decay
8209 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8210 } else if (fstate == 1){
8211 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8212 dBrHXXRatio1 = BrHXXRatio - 1.0;
8213 dBrHXXRatio2 = 0.0;
8214 } else if (fstate == 2){
8215 BrHXXRatio = (myNPbase->BrHgagaRatio());
8216 dBrHXXRatio1 = BrHXXRatio - 1.0;
8217 dBrHXXRatio2 = 0.0;
8218 } else if (fstate == 3){
8219 BrHXXRatio = (myNPbase->BrHbbRatio());
8220 dBrHXXRatio1 = BrHXXRatio - 1.0;
8221 dBrHXXRatio2 = 0.0;
8222 } else if (fstate == 4){
8223 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8224 dBrHXXRatio1 = BrHXXRatio - 1.0;
8225 dBrHXXRatio2 = 0.0;
8226 } else if (fstate == 5){
8227 BrHXXRatio = (myNPbase->BrHtautauRatio());
8228 dBrHXXRatio1 = BrHXXRatio - 1.0;
8229 dBrHXXRatio2 = 0.0;
8230 } else if (fstate == 6){
8231 BrHXXRatio = (myNPbase->BrHWWRatio());
8232 dBrHXXRatio1 = BrHXXRatio - 1.0;
8233 dBrHXXRatio2 = 0.0;
8234 } else if (fstate == 7){
8235 BrHXXRatio = (myNPbase->BrHZZRatio());
8236 dBrHXXRatio1 = BrHXXRatio - 1.0;
8237 dBrHXXRatio2 = 0.0;
8238 } else {
8239 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8240 }
8241
8242 //-- Production x Decay:
8243 if ((this->getModel()).isModelLinearized()){
8244 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8245 } else if((this->getModel()).isModelNPquadratic()){
8246 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8247 } else {
8248 return weight*(muProd)*(BrHXXRatio);
8249 }
8250
8251}
8252
8253
8254
8255// -----------------------------------------------------------------------------
8256
8257
8258//VM:STXS2024;
8259STXS12_ggH_pTH650_Inf::STXS12_ggH_pTH650_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8260: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8261{
8262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8263 throw std::runtime_error("STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8264
8265}
8266
8268{
8269 //-- Production:
8270 double weight = 1.0; //If normalized to the SM
8271 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8272 double muProd = myNPbase->STXS12_ggH_pTH650_Inf(sqrt_s);
8273 double muProd1 = muProd -1.0;
8274 double muProd2 = 0.0;
8275
8276 //-- Decay:
8277 double BrHXXRatio = 1.0;
8278 double dBrHXXRatio1 = 0.0;
8279 double dBrHXXRatio2 = 0.0;
8280 if (fstate==0){
8281 // Use for Cross-section [pb] with no Higgs-boson decay
8282 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8283 } else if (fstate == 1){
8284 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8285 dBrHXXRatio1 = BrHXXRatio - 1.0;
8286 dBrHXXRatio2 = 0.0;
8287 } else if (fstate == 2){
8288 BrHXXRatio = (myNPbase->BrHgagaRatio());
8289 dBrHXXRatio1 = BrHXXRatio - 1.0;
8290 dBrHXXRatio2 = 0.0;
8291 } else if (fstate == 3){
8292 BrHXXRatio = (myNPbase->BrHbbRatio());
8293 dBrHXXRatio1 = BrHXXRatio - 1.0;
8294 dBrHXXRatio2 = 0.0;
8295 } else if (fstate == 4){
8296 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8297 dBrHXXRatio1 = BrHXXRatio - 1.0;
8298 dBrHXXRatio2 = 0.0;
8299 } else if (fstate == 5){
8300 BrHXXRatio = (myNPbase->BrHtautauRatio());
8301 dBrHXXRatio1 = BrHXXRatio - 1.0;
8302 dBrHXXRatio2 = 0.0;
8303 } else if (fstate == 6){
8304 BrHXXRatio = (myNPbase->BrHWWRatio());
8305 dBrHXXRatio1 = BrHXXRatio - 1.0;
8306 dBrHXXRatio2 = 0.0;
8307 } else if (fstate == 7){
8308 BrHXXRatio = (myNPbase->BrHZZRatio());
8309 dBrHXXRatio1 = BrHXXRatio - 1.0;
8310 dBrHXXRatio2 = 0.0;
8311 } else {
8312 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8313 }
8314
8315 //-- Production x Decay:
8316 if ((this->getModel()).isModelLinearized()){
8317 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8318 } else if((this->getModel()).isModelNPquadratic()){
8319 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8320 } else {
8321 return weight*(muProd)*(BrHXXRatio);
8322 }
8323
8324}
8325
8326
8327
8328// -----------------------------------------------------------------------------
8329
8330
8331//VM:STXS2024;
8332STXS12_ggH_pTH450_Inf::STXS12_ggH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8333: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8334{
8335 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8336 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8337
8338}
8339
8341{
8342 //-- Production:
8343 double weight = 1.0; //If normalized to the SM
8344 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8345 double muProd = myNPbase->STXS12_ggH_pTH450_Inf(sqrt_s);
8346 double muProd1 = muProd -1.0;
8347 double muProd2 = 0.0;
8348
8349 //-- Decay:
8350 double BrHXXRatio = 1.0;
8351 double dBrHXXRatio1 = 0.0;
8352 double dBrHXXRatio2 = 0.0;
8353 if (fstate==0){
8354 // Use for Cross-section [pb] with no Higgs-boson decay
8355 weight = 0.017974; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8356 } else if (fstate == 1){
8357 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8358 dBrHXXRatio1 = BrHXXRatio - 1.0;
8359 dBrHXXRatio2 = 0.0;
8360 } else if (fstate == 2){
8361 BrHXXRatio = (myNPbase->BrHgagaRatio());
8362 dBrHXXRatio1 = BrHXXRatio - 1.0;
8363 dBrHXXRatio2 = 0.0;
8364 } else if (fstate == 3){
8365 BrHXXRatio = (myNPbase->BrHbbRatio());
8366 dBrHXXRatio1 = BrHXXRatio - 1.0;
8367 dBrHXXRatio2 = 0.0;
8368 } else if (fstate == 4){
8369 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8370 dBrHXXRatio1 = BrHXXRatio - 1.0;
8371 dBrHXXRatio2 = 0.0;
8372 } else if (fstate == 5){
8373 BrHXXRatio = (myNPbase->BrHtautauRatio());
8374 dBrHXXRatio1 = BrHXXRatio - 1.0;
8375 dBrHXXRatio2 = 0.0;
8376 } else if (fstate == 6){
8377 BrHXXRatio = (myNPbase->BrHWWRatio());
8378 dBrHXXRatio1 = BrHXXRatio - 1.0;
8379 dBrHXXRatio2 = 0.0;
8380 } else if (fstate == 7){
8381 BrHXXRatio = (myNPbase->BrHZZRatio());
8382 dBrHXXRatio1 = BrHXXRatio - 1.0;
8383 dBrHXXRatio2 = 0.0;
8384 } else {
8385 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8386 }
8387
8388 //-- Production x Decay:
8389 if ((this->getModel()).isModelLinearized()){
8390 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8391 } else if((this->getModel()).isModelNPquadratic()){
8392 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8393 } else {
8394 return weight*(muProd)*(BrHXXRatio);
8395 }
8396
8397}
8398
8399
8400// -----------------------------------------------------------------------------
8401
8402STXS12_ggHll_pTV0_75::STXS12_ggHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8403: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8404{
8405 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8406 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
8407
8408}
8409
8411{
8412 double BrHXXRatio = 1.0;
8413 if (fstate == 1){
8414 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8415 } else if (fstate == 2){
8416 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8417 } else if (fstate == 3){
8418 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8419 } else if (fstate == 4){
8420 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8421 } else {
8422 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
8423 }
8424
8425 if ((this->getModel()).isModelLinearized()) {
8426 return ((myNPbase->STXS12_ggHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
8427 } else {
8428 return (myNPbase->STXS12_ggHll_pTV0_75(sqrt_s))*(BrHXXRatio);
8429 }
8430}
8431
8432// -----------------------------------------------------------------------------
8433
8434STXS12_ggHll_pTV75_150::STXS12_ggHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8435: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8436{
8437 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8438 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
8439
8440}
8441
8443{
8444 double BrHXXRatio = 1.0;
8445 if (fstate == 1){
8446 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8447 } else if (fstate == 2){
8448 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8449 } else if (fstate == 3){
8450 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8451 } else if (fstate == 4){
8452 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8453 } else {
8454 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
8455 }
8456
8457 if ((this->getModel()).isModelLinearized()) {
8458 return ((myNPbase->STXS12_ggHll_pTV75_150(sqrt_s)) + (BrHXXRatio) - 1.0);
8459 } else {
8460 return (myNPbase->STXS12_ggHll_pTV75_150(sqrt_s))*(BrHXXRatio);
8461 }
8462}
8463
8464// -----------------------------------------------------------------------------
8465
8466STXS12_ggHll_pTV150_250_Nj0::STXS12_ggHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8467: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8468{
8469 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8470 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
8471
8472}
8473
8475{
8476 double BrHXXRatio = 1.0;
8477 if (fstate == 1){
8478 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8479 } else if (fstate == 2){
8480 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8481 } else if (fstate == 3){
8482 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8483 } else if (fstate == 4){
8484 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8485 } else {
8486 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
8487 }
8488
8489 if ((this->getModel()).isModelLinearized()) {
8490 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8491 } else {
8492 return (myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s))*(BrHXXRatio);
8493 }
8494}
8495
8496// -----------------------------------------------------------------------------
8497
8498STXS12_ggHll_pTV150_250_Nj1::STXS12_ggHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8499: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8500{
8501 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8502 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
8503
8504}
8505
8507{
8508 double BrHXXRatio = 1.0;
8509 if (fstate == 1){
8510 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8511 } else if (fstate == 2){
8512 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8513 } else if (fstate == 3){
8514 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8515 } else if (fstate == 4){
8516 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8517 } else {
8518 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
8519 }
8520
8521 if ((this->getModel()).isModelLinearized()) {
8522 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8523 } else {
8524 return (myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
8525 }
8526}
8527
8528// -----------------------------------------------------------------------------
8529
8530STXS12_ggHll_pTV250_Inf::STXS12_ggHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8531: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8532{
8533 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8534 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
8535
8536}
8537
8539{
8540 double BrHXXRatio = 1.0;
8541 if (fstate == 1){
8542 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8543 } else if (fstate == 2){
8544 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8545 } else if (fstate == 3){
8546 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8547 } else if (fstate == 4){
8548 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8549 } else {
8550 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
8551 }
8552
8553 if ((this->getModel()).isModelLinearized()) {
8554 return ((myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
8555 } else {
8556 return (myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
8557 }
8558}
8559
8560// -----------------------------------------------------------------------------
8561
8562STXS12_qqHqq_Nj0::STXS12_qqHqq_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8563: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8564{
8565 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8566 throw std::runtime_error("STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
8567
8568}
8569
8571{
8572 double BrHXXRatio = 1.0;
8573 if (fstate == 1){
8574 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8575 } else if (fstate == 2){
8576 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8577 } else if (fstate == 3){
8578 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8579 } else if (fstate == 4){
8580 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8581 } else {
8582 throw std::runtime_error("STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
8583 }
8584
8585 if ((this->getModel()).isModelLinearized()) {
8586 return ((myNPbase->STXS12_qqHqq_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8587 } else {
8588 return (myNPbase->STXS12_qqHqq_Nj0(sqrt_s))*(BrHXXRatio);
8589 }
8590}
8591
8592// -----------------------------------------------------------------------------
8593
8594STXS12_qqHqq_Nj1::STXS12_qqHqq_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8595: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8596{
8597 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8598 throw std::runtime_error("STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
8599
8600}
8601
8603{
8604 double BrHXXRatio = 1.0;
8605 if (fstate == 1){
8606 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8607 } else if (fstate == 2){
8608 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8609 } else if (fstate == 3){
8610 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8611 } else if (fstate == 4){
8612 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8613 } else {
8614 throw std::runtime_error("STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
8615 }
8616
8617 if ((this->getModel()).isModelLinearized()) {
8618 return ((myNPbase->STXS12_qqHqq_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8619 } else {
8620 return (myNPbase->STXS12_qqHqq_Nj1(sqrt_s))*(BrHXXRatio);
8621 }
8622}
8623
8624// -----------------------------------------------------------------------------
8625
8626STXS12_qqHqq_mjj0_60_Nj2::STXS12_qqHqq_mjj0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8627: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8628{
8629 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8630 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
8631
8632}
8633
8635{
8636 double BrHXXRatio = 1.0;
8637 if (fstate == 1){
8638 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8639 } else if (fstate == 2){
8640 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8641 } else if (fstate == 3){
8642 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8643 } else if (fstate == 4){
8644 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8645 } else {
8646 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
8647 }
8648
8649 if ((this->getModel()).isModelLinearized()) {
8650 return ((myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8651 } else {
8652 return (myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s))*(BrHXXRatio);
8653 }
8654}
8655
8656
8657
8658// -----------------------------------------------------------------------------
8659
8660
8661//VM:STXS2024;
8662STXS12_qqHqq_VH_veto_Nj01::STXS12_qqHqq_VH_veto_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8663: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8664{
8665 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8666 throw std::runtime_error("STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
8667
8668}
8669
8671{
8672 //-- Production:
8673 double weight = 1.0; //If normalized to the SM
8674 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8675 double muProd = myNPbase->STXS12_qqHqq_VH_veto_Nj01(sqrt_s);
8676 double muProd1 = muProd -1.0;
8677 double muProd2 = 0.0;
8678
8679 //-- Decay:
8680 double BrHXXRatio = 1.0;
8681 double dBrHXXRatio1 = 0.0;
8682 double dBrHXXRatio2 = 0.0;
8683 if (fstate==0){
8684 // Use for Cross-section [pb] with no Higgs-boson decay
8685 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8686 } else if (fstate == 1){
8687 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8688 dBrHXXRatio1 = BrHXXRatio - 1.0;
8689 dBrHXXRatio2 = 0.0;
8690 } else if (fstate == 2){
8691 BrHXXRatio = (myNPbase->BrHgagaRatio());
8692 dBrHXXRatio1 = BrHXXRatio - 1.0;
8693 dBrHXXRatio2 = 0.0;
8694 } else if (fstate == 3){
8695 BrHXXRatio = (myNPbase->BrHbbRatio());
8696 dBrHXXRatio1 = BrHXXRatio - 1.0;
8697 dBrHXXRatio2 = 0.0;
8698 } else if (fstate == 4){
8699 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8700 dBrHXXRatio1 = BrHXXRatio - 1.0;
8701 dBrHXXRatio2 = 0.0;
8702 } else if (fstate == 5){
8703 BrHXXRatio = (myNPbase->BrHtautauRatio());
8704 dBrHXXRatio1 = BrHXXRatio - 1.0;
8705 dBrHXXRatio2 = 0.0;
8706 } else if (fstate == 6){
8707 BrHXXRatio = (myNPbase->BrHWWRatio());
8708 dBrHXXRatio1 = BrHXXRatio - 1.0;
8709 dBrHXXRatio2 = 0.0;
8710 } else if (fstate == 7){
8711 BrHXXRatio = (myNPbase->BrHZZRatio());
8712 dBrHXXRatio1 = BrHXXRatio - 1.0;
8713 dBrHXXRatio2 = 0.0;
8714 } else {
8715 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8716 }
8717
8718 //-- Production x Decay:
8719 if ((this->getModel()).isModelLinearized()){
8720 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8721 } else if((this->getModel()).isModelNPquadratic()){
8722 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8723 } else {
8724 return weight*(muProd)*(BrHXXRatio);
8725 }
8726
8727}
8728
8729
8730
8731
8732// -----------------------------------------------------------------------------
8733
8734
8735//VM:STXS2024;
8736STXS12_qqHqq_VH_had_Nj2::STXS12_qqHqq_VH_had_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8737: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8738{
8739 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8740 throw std::runtime_error("STXS12_qqHqq_VH_had_Nj2 called with a class whose parent is not NPbase");
8741
8742}
8743
8745{
8746 //-- Production:
8747 double weight = 1.0; //If normalized to the SM
8748 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8749 double muProd = myNPbase->STXS12_qqHqq_VH_had_Nj2(sqrt_s);
8750 double muProd1 = muProd -1.0;
8751 double muProd2 = 0.0;
8752
8753 //-- Decay:
8754 double BrHXXRatio = 1.0;
8755 double dBrHXXRatio1 = 0.0;
8756 double dBrHXXRatio2 = 0.0;
8757 if (fstate==0){
8758 // Use for Cross-section [pb] with no Higgs-boson decay
8759 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8760 } else if (fstate == 1){
8761 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8762 dBrHXXRatio1 = BrHXXRatio - 1.0;
8763 dBrHXXRatio2 = 0.0;
8764 } else if (fstate == 2){
8765 BrHXXRatio = (myNPbase->BrHgagaRatio());
8766 dBrHXXRatio1 = BrHXXRatio - 1.0;
8767 dBrHXXRatio2 = 0.0;
8768 } else if (fstate == 3){
8769 BrHXXRatio = (myNPbase->BrHbbRatio());
8770 dBrHXXRatio1 = BrHXXRatio - 1.0;
8771 dBrHXXRatio2 = 0.0;
8772 } else if (fstate == 4){
8773 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8774 dBrHXXRatio1 = BrHXXRatio - 1.0;
8775 dBrHXXRatio2 = 0.0;
8776 } else if (fstate == 5){
8777 BrHXXRatio = (myNPbase->BrHtautauRatio());
8778 dBrHXXRatio1 = BrHXXRatio - 1.0;
8779 dBrHXXRatio2 = 0.0;
8780 } else if (fstate == 6){
8781 BrHXXRatio = (myNPbase->BrHWWRatio());
8782 dBrHXXRatio1 = BrHXXRatio - 1.0;
8783 dBrHXXRatio2 = 0.0;
8784 } else if (fstate == 7){
8785 BrHXXRatio = (myNPbase->BrHZZRatio());
8786 dBrHXXRatio1 = BrHXXRatio - 1.0;
8787 dBrHXXRatio2 = 0.0;
8788 } else {
8789 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8790 }
8791
8792 //-- Production x Decay:
8793 if ((this->getModel()).isModelLinearized()){
8794 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8795 } else if((this->getModel()).isModelNPquadratic()){
8796 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8797 } else {
8798 return weight*(muProd)*(BrHXXRatio);
8799 }
8800
8801}
8802
8803
8804
8805// -----------------------------------------------------------------------------
8806
8807//AG:STXS2024
8808STXS12_qqHqq_mjj60_120_Nj2::STXS12_qqHqq_mjj60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8809: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8810{
8811 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8812 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
8813
8814}
8815
8817{
8818 //-- Production:
8819 double weight = 1.0; //If normalized to the SM
8820 double muProd = myNPbase->STXS12_qqHqq_mjj60_120_Nj2(sqrt_s);
8821 double muProd1 = muProd -1.0;
8822 double muProd2 = 0.0;
8823
8824 //-- Decay:
8825 double BrHXXRatio = 1.0;
8826 double dBrHXXRatio1 = 0.0;
8827 double dBrHXXRatio2 = 0.0;
8828 if (fstate==0){
8829 // Use for Cross-section [pb] with no Higgs-boson decay
8830 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8831 } else if (fstate == 1){
8832 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8833 dBrHXXRatio1 = BrHXXRatio - 1.0;
8834 dBrHXXRatio2 = 0.0;
8835 } else if (fstate == 2){
8836 BrHXXRatio = (myNPbase->BrHgagaRatio());
8837 dBrHXXRatio1 = BrHXXRatio - 1.0;
8838 dBrHXXRatio2 = 0.0;
8839 } else if (fstate == 3){
8840 BrHXXRatio = (myNPbase->BrHbbRatio());
8841 dBrHXXRatio1 = BrHXXRatio - 1.0;
8842 dBrHXXRatio2 = 0.0;
8843 } else if (fstate == 4){
8844 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8845 dBrHXXRatio1 = BrHXXRatio - 1.0;
8846 dBrHXXRatio2 = 0.0;
8847 } else if (fstate == 5){
8848 BrHXXRatio = (myNPbase->BrHtautauRatio());
8849 dBrHXXRatio1 = BrHXXRatio - 1.0;
8850 dBrHXXRatio2 = 0.0;
8851 } else if (fstate == 6){
8852 BrHXXRatio = (myNPbase->BrHWWRatio());
8853 dBrHXXRatio1 = BrHXXRatio - 1.0;
8854 dBrHXXRatio2 = 0.0;
8855 } else if (fstate == 7){
8856 BrHXXRatio = (myNPbase->BrHZZRatio());
8857 dBrHXXRatio1 = BrHXXRatio - 1.0;
8858 dBrHXXRatio2 = 0.0;
8859 } else {
8860 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
8861 }
8862
8863 //-- Production x Decay:
8864 if ((this->getModel()).isModelLinearized()){
8865 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8866 } else if((this->getModel()).isModelNPquadratic()){
8867 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8868 } else {
8869 return weight*(muProd)*(BrHXXRatio);
8870 }
8871}
8872
8873// -----------------------------------------------------------------------------
8874
8875STXS12_qqHqq_mjj120_350_Nj2::STXS12_qqHqq_mjj120_350_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8876: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8877{
8878 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8879 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
8880
8881}
8882
8884{
8885 double BrHXXRatio = 1.0;
8886 if (fstate == 1){
8887 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8888 } else if (fstate == 2){
8889 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8890 } else if (fstate == 3){
8891 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8892 } else if (fstate == 4){
8893 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8894 } else {
8895 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
8896 }
8897
8898 if ((this->getModel()).isModelLinearized()) {
8899 return ((myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8900 } else {
8901 return (myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s))*(BrHXXRatio);
8902 }
8903}
8904
8905// -----------------------------------------------------------------------------
8906
8907//AG:STXS2024
8909: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8910{
8911 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8912 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
8913
8914}
8915
8917{
8918 //-- Production:
8919 double weight = 1.0; //If normalized to the SM
8921 double muProd1 = muProd -1.0;
8922 double muProd2 = 0.0;
8923
8924 //-- Decay:
8925 double BrHXXRatio = 1.0;
8926 double dBrHXXRatio1 = 0.0;
8927 double dBrHXXRatio2 = 0.0;
8928 if (fstate==0){
8929 // Use for Cross-section [pb] with no Higgs-boson decay
8930 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8931 } else if (fstate == 1){
8932 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8933 dBrHXXRatio1 = BrHXXRatio - 1.0;
8934 dBrHXXRatio2 = 0.0;
8935 } else if (fstate == 2){
8936 BrHXXRatio = (myNPbase->BrHgagaRatio());
8937 dBrHXXRatio1 = BrHXXRatio - 1.0;
8938 dBrHXXRatio2 = 0.0;
8939 } else if (fstate == 3){
8940 BrHXXRatio = (myNPbase->BrHbbRatio());
8941 dBrHXXRatio1 = BrHXXRatio - 1.0;
8942 dBrHXXRatio2 = 0.0;
8943 } else if (fstate == 4){
8944 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8945 dBrHXXRatio1 = BrHXXRatio - 1.0;
8946 dBrHXXRatio2 = 0.0;
8947 } else if (fstate == 5){
8948 BrHXXRatio = (myNPbase->BrHtautauRatio());
8949 dBrHXXRatio1 = BrHXXRatio - 1.0;
8950 dBrHXXRatio2 = 0.0;
8951 } else if (fstate == 6){
8952 BrHXXRatio = (myNPbase->BrHWWRatio());
8953 dBrHXXRatio1 = BrHXXRatio - 1.0;
8954 dBrHXXRatio2 = 0.0;
8955 } else if (fstate == 7){
8956 BrHXXRatio = (myNPbase->BrHZZRatio());
8957 dBrHXXRatio1 = BrHXXRatio - 1.0;
8958 dBrHXXRatio2 = 0.0;
8959 } else {
8960 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
8961 }
8962
8963
8964 //-- Production x Decay:
8965 if ((this->getModel()).isModelLinearized()){
8966 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8967 } else if((this->getModel()).isModelNPquadratic()){
8968 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8969 } else {
8970 return weight*(muProd)*(BrHXXRatio);
8971 }
8972
8973}
8974
8975// -----------------------------------------------------------------------------
8976
8978: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8979{
8980 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8981 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
8982
8983}
8984
8986{
8987 double BrHXXRatio = 1.0;
8988 if (fstate == 1){
8989 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8990 } else if (fstate == 2){
8991 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8992 } else if (fstate == 3){
8993 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8994 } else if (fstate == 4){
8995 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8996 } else {
8997 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8998 }
8999
9000 if ((this->getModel()).isModelLinearized()) {
9001 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9002 } else {
9004 }
9005}
9006
9007// -----------------------------------------------------------------------------
9008
9010: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9011{
9012 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9013 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9014
9015}
9016
9018{
9019 double BrHXXRatio = 1.0;
9020 if (fstate == 1){
9021 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9022 } else if (fstate == 2){
9023 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9024 } else if (fstate == 3){
9025 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9026 } else if (fstate == 4){
9027 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9028 } else {
9029 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9030 }
9031
9032 if ((this->getModel()).isModelLinearized()) {
9033 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9034 } else {
9036 }
9037}
9038
9039// -----------------------------------------------------------------------------
9040
9042: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9043{
9044 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9045 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9046
9047}
9048
9050{
9051 double BrHXXRatio = 1.0;
9052 if (fstate == 1){
9053 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9054 } else if (fstate == 2){
9055 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9056 } else if (fstate == 3){
9057 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9058 } else if (fstate == 4){
9059 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9060 } else {
9061 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9062 }
9063
9064 if ((this->getModel()).isModelLinearized()) {
9065 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9066 } else {
9068 }
9069}
9070
9071// -----------------------------------------------------------------------------
9072
9074: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9075{
9076 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9077 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9078
9079}
9080
9082{
9083 double BrHXXRatio = 1.0;
9084 if (fstate == 1){
9085 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9086 } else if (fstate == 2){
9087 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9088 } else if (fstate == 3){
9089 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9090 } else if (fstate == 4){
9091 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9092 } else {
9093 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9094 }
9095
9096 if ((this->getModel()).isModelLinearized()) {
9097 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9098 } else {
9100 }
9101}
9102
9103// -----------------------------------------------------------------------------
9104
9105//AG:STXS2024
9106STXS12_qqHqq_mjj350_700_pTH0_200_Nj2::STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9107: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9108{
9109 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9110 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9111
9112}
9113
9115{
9116 //-- Production:
9117 double weight = 1.0; //If normalized to the SM
9119 double muProd1 = muProd -1.0;
9120 double muProd2 = 0.0;
9121
9122 //-- Decay:
9123 double BrHXXRatio = 1.0;
9124 double dBrHXXRatio1 = 0.0;
9125 double dBrHXXRatio2 = 0.0;
9126 if (fstate==0){
9127 // Use for Cross-section [pb] with no Higgs-boson decay
9128 weight = 0.53537; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9129 } else if (fstate == 1){
9130 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9131 dBrHXXRatio1 = BrHXXRatio - 1.0;
9132 dBrHXXRatio2 = 0.0;
9133 } else if (fstate == 2){
9134 BrHXXRatio = (myNPbase->BrHgagaRatio());
9135 dBrHXXRatio1 = BrHXXRatio - 1.0;
9136 dBrHXXRatio2 = 0.0;
9137 } else if (fstate == 3){
9138 BrHXXRatio = (myNPbase->BrHbbRatio());
9139 dBrHXXRatio1 = BrHXXRatio - 1.0;
9140 dBrHXXRatio2 = 0.0;
9141 } else if (fstate == 4){
9142 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9143 dBrHXXRatio1 = BrHXXRatio - 1.0;
9144 dBrHXXRatio2 = 0.0;
9145 } else if (fstate == 5){
9146 BrHXXRatio = (myNPbase->BrHtautauRatio());
9147 dBrHXXRatio1 = BrHXXRatio - 1.0;
9148 dBrHXXRatio2 = 0.0;
9149 } else if (fstate == 6){
9150 BrHXXRatio = (myNPbase->BrHWWRatio());
9151 dBrHXXRatio1 = BrHXXRatio - 1.0;
9152 dBrHXXRatio2 = 0.0;
9153 } else {
9154 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9155 }
9156
9157 //-- Production x Decay:
9158 if ((this->getModel()).isModelLinearized()){
9159 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9160 } else if((this->getModel()).isModelNPquadratic()){
9161 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9162 } else {
9163 return weight*(muProd)*(BrHXXRatio);
9164 }
9165
9166
9167}
9168
9169// -----------------------------------------------------------------------------
9170
9171//AG:STXS2024
9172STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2::STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9173: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9174{
9175 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9176 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9177
9178}
9179
9181{
9182 //-- Production:
9183 double weight = 1.0; //If normalized to the SM
9185 double muProd1 = muProd -1.0;
9186 double muProd2 = 0.0;
9187
9188 //-- Decay:
9189 double BrHXXRatio = 1.0;
9190 double dBrHXXRatio1 = 0.0;
9191 double dBrHXXRatio2 = 0.0;
9192 if (fstate==0){
9193 // Use for Cross-section [pb] with no Higgs-boson decay
9194 weight = 0.25614; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9195 } else if (fstate == 1){
9196 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9197 dBrHXXRatio1 = BrHXXRatio - 1.0;
9198 dBrHXXRatio2 = 0.0;
9199 } else if (fstate == 2){
9200 BrHXXRatio = (myNPbase->BrHgagaRatio());
9201 dBrHXXRatio1 = BrHXXRatio - 1.0;
9202 dBrHXXRatio2 = 0.0;
9203 } else if (fstate == 3){
9204 BrHXXRatio = (myNPbase->BrHbbRatio());
9205 dBrHXXRatio1 = BrHXXRatio - 1.0;
9206 dBrHXXRatio2 = 0.0;
9207 } else if (fstate == 4){
9208 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9209 dBrHXXRatio1 = BrHXXRatio - 1.0;
9210 dBrHXXRatio2 = 0.0;
9211 } else if (fstate == 5){
9212 BrHXXRatio = (myNPbase->BrHtautauRatio());
9213 dBrHXXRatio1 = BrHXXRatio - 1.0;
9214 dBrHXXRatio2 = 0.0;
9215 } else if (fstate == 6){
9216 BrHXXRatio = (myNPbase->BrHWWRatio());
9217 dBrHXXRatio1 = BrHXXRatio - 1.0;
9218 dBrHXXRatio2 = 0.0;
9219 } else {
9220 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9221 }
9222
9223 //-- Production x Decay:
9224 if ((this->getModel()).isModelLinearized()){
9225 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9226 } else if((this->getModel()).isModelNPquadratic()){
9227 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9228 } else {
9229 return weight*(muProd)*(BrHXXRatio);
9230 }
9231
9232
9233}
9234
9235// -----------------------------------------------------------------------------
9236
9237//AG:STXS2024
9238STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9239: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9240{
9241 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9242 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9243
9244}
9245
9247{
9248 //-- Production:
9249 double weight = 1.0; //If normalized to the SM
9251 double muProd1 = muProd -1.0;
9252 double muProd2 = 0.0;
9253
9254 //-- Decay:
9255 double BrHXXRatio = 1.0;
9256 double dBrHXXRatio1 = 0.0;
9257 double dBrHXXRatio2 = 0.0;
9258 if (fstate==0){
9259 // Use for Cross-section [pb] with no Higgs-boson decay
9260 weight = 0.22408; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9261 } else if (fstate == 1){
9262 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9263 dBrHXXRatio1 = BrHXXRatio - 1.0;
9264 dBrHXXRatio2 = 0.0;
9265 } else if (fstate == 2){
9266 BrHXXRatio = (myNPbase->BrHgagaRatio());
9267 dBrHXXRatio1 = BrHXXRatio - 1.0;
9268 dBrHXXRatio2 = 0.0;
9269 } else if (fstate == 3){
9270 BrHXXRatio = (myNPbase->BrHbbRatio());
9271 dBrHXXRatio1 = BrHXXRatio - 1.0;
9272 dBrHXXRatio2 = 0.0;
9273 } else if (fstate == 4){
9274 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9275 dBrHXXRatio1 = BrHXXRatio - 1.0;
9276 dBrHXXRatio2 = 0.0;
9277 } else if (fstate == 5){
9278 BrHXXRatio = (myNPbase->BrHtautauRatio());
9279 dBrHXXRatio1 = BrHXXRatio - 1.0;
9280 dBrHXXRatio2 = 0.0;
9281 } else if (fstate == 6){
9282 BrHXXRatio = (myNPbase->BrHWWRatio());
9283 dBrHXXRatio1 = BrHXXRatio - 1.0;
9284 dBrHXXRatio2 = 0.0;
9285 } else {
9286 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9287 }
9288
9289 //-- Production x Decay:
9290 if ((this->getModel()).isModelLinearized()){
9291 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9292 } else if((this->getModel()).isModelNPquadratic()){
9293 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9294 } else {
9295 return weight*(muProd)*(BrHXXRatio);
9296 }
9297
9298
9299}
9300
9301// -----------------------------------------------------------------------------
9302
9303//AG:STXS2024
9304STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9305: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9306{
9307 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9308 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9309
9310}
9311
9313{
9314 //-- Production:
9315 double weight = 1.0; //If normalized to the SM
9317 double muProd1 = muProd -1.0;
9318 double muProd2 = 0.0;
9319
9320 //-- Decay:
9321 double BrHXXRatio = 1.0;
9322 double dBrHXXRatio1 = 0.0;
9323 double dBrHXXRatio2 = 0.0;
9324 if (fstate==0){
9325 // Use for Cross-section [pb] with no Higgs-boson decay
9326 weight = 0.21578; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9327 } else if (fstate == 1){
9328 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9329 dBrHXXRatio1 = BrHXXRatio - 1.0;
9330 dBrHXXRatio2 = 0.0;
9331 } else if (fstate == 2){
9332 BrHXXRatio = (myNPbase->BrHgagaRatio());
9333 dBrHXXRatio1 = BrHXXRatio - 1.0;
9334 dBrHXXRatio2 = 0.0;
9335 } else if (fstate == 3){
9336 BrHXXRatio = (myNPbase->BrHbbRatio());
9337 dBrHXXRatio1 = BrHXXRatio - 1.0;
9338 dBrHXXRatio2 = 0.0;
9339 } else if (fstate == 4){
9340 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9341 dBrHXXRatio1 = BrHXXRatio - 1.0;
9342 dBrHXXRatio2 = 0.0;
9343 } else if (fstate == 5){
9344 BrHXXRatio = (myNPbase->BrHtautauRatio());
9345 dBrHXXRatio1 = BrHXXRatio - 1.0;
9346 dBrHXXRatio2 = 0.0;
9347 } else if (fstate == 6){
9348 BrHXXRatio = (myNPbase->BrHWWRatio());
9349 dBrHXXRatio1 = BrHXXRatio - 1.0;
9350 dBrHXXRatio2 = 0.0;
9351 } else {
9352 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9353 }
9354
9355 //-- Production x Decay:
9356 if ((this->getModel()).isModelLinearized()){
9357 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9358 } else if((this->getModel()).isModelNPquadratic()){
9359 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9360 } else {
9361 return weight*(muProd)*(BrHXXRatio);
9362 }
9363
9364}
9365
9366// -----------------------------------------------------------------------------
9367
9368//AG:STXS2024
9369STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9370: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9371{
9372 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9373 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9374
9375}
9376
9378{
9379 //-- Production:
9380 double weight = 1.0; //If normalized to the SM
9381 //Since adding bins, include partial weigths of SM_predictions
9382 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9383 double muProd = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s))
9384 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)) / (0.30189+0.21578));
9385 double muProd1 = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s)-1.0)
9386 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)-1.0) / (0.30189+0.21578));
9387 double muProd2 = 0.0;
9388
9389 //-- Decay:
9390 double BrHXXRatio = 1.0;
9391 double dBrHXXRatio1 = 0.0;
9392 double dBrHXXRatio2 = 0.0;
9393 if (fstate==0){
9394 // Use for Cross-section [pb] with no Higgs-boson decay
9395 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9396 } else if (fstate == 1){
9397 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9398 dBrHXXRatio1 = BrHXXRatio - 1.0;
9399 dBrHXXRatio2 = 0.0;
9400 } else if (fstate == 2){
9401 BrHXXRatio = (myNPbase->BrHgagaRatio());
9402 dBrHXXRatio1 = BrHXXRatio - 1.0;
9403 dBrHXXRatio2 = 0.0;
9404 } else if (fstate == 3){
9405 BrHXXRatio = (myNPbase->BrHbbRatio());
9406 dBrHXXRatio1 = BrHXXRatio - 1.0;
9407 dBrHXXRatio2 = 0.0;
9408 } else if (fstate == 4){
9409 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9410 dBrHXXRatio1 = BrHXXRatio - 1.0;
9411 dBrHXXRatio2 = 0.0;
9412 } else {
9413 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9414 }
9415
9416 //-- Production x Decay:
9417 if ((this->getModel()).isModelLinearized()){
9418 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9419 } else if((this->getModel()).isModelNPquadratic()){
9420 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9421 } else {
9422 return weight*(muProd)*(BrHXXRatio);
9423 }
9424
9425
9426}
9427
9428// -----------------------------------------------------------------------------
9429
9430//AG:STXS2024
9431STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2::STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9432: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9433{
9434 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9435 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9436
9437}
9438
9440{
9441 //-- Production:
9442 double weight = 1.0; //If normalized to the SM
9444 double muProd1 = muProd -1.0;
9445 double muProd2 = 0.0;
9446
9447 //-- Decay:
9448 double BrHXXRatio = 1.0;
9449 double dBrHXXRatio1 = 0.0;
9450 double dBrHXXRatio2 = 0.0;
9451 if (fstate==0){
9452 // Use for Cross-section [pb] with no Higgs-boson decay
9453 weight = 0.07372 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9454 } else if (fstate == 1){
9455 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9456 dBrHXXRatio1 = BrHXXRatio - 1.0;
9457 dBrHXXRatio2 = 0.0;
9458 } else if (fstate == 2){
9459 BrHXXRatio = (myNPbase->BrHgagaRatio());
9460 dBrHXXRatio1 = BrHXXRatio - 1.0;
9461 dBrHXXRatio2 = 0.0;
9462 } else if (fstate == 3){
9463 BrHXXRatio = (myNPbase->BrHbbRatio());
9464 dBrHXXRatio1 = BrHXXRatio - 1.0;
9465 dBrHXXRatio2 = 0.0;
9466 } else if (fstate == 4){
9467 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9468 dBrHXXRatio1 = BrHXXRatio - 1.0;
9469 dBrHXXRatio2 = 0.0;
9470 } else {
9471 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9472 }
9473
9474 //-- Production x Decay:
9475 if ((this->getModel()).isModelLinearized()){
9476 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9477 } else if((this->getModel()).isModelNPquadratic()){
9478 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9479 } else {
9480 return weight*(muProd)*(BrHXXRatio);
9481 }
9482
9483
9484}
9485
9486// -----------------------------------------------------------------------------
9487
9488//AG:STXS2024
9489STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9490: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9491{
9492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9493 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9494
9495}
9496
9498{
9499 //-- Production:
9500 double weight = 1.0; //If normalized to the SM
9502 double muProd1 = muProd -1.0;
9503 double muProd2 = 0.0;
9504
9505 //-- Decay:
9506 double BrHXXRatio = 1.0;
9507 double dBrHXXRatio1 = 0.0;
9508 double dBrHXXRatio2 = 0.0;
9509 if (fstate==0){
9510 // Use for Cross-section [pb] with no Higgs-boson decay
9511 weight = 0.07315 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9512 } else if (fstate == 1){
9513 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9514 dBrHXXRatio1 = BrHXXRatio - 1.0;
9515 dBrHXXRatio2 = 0.0;
9516 } else if (fstate == 2){
9517 BrHXXRatio = (myNPbase->BrHgagaRatio());
9518 dBrHXXRatio1 = BrHXXRatio - 1.0;
9519 dBrHXXRatio2 = 0.0;
9520 } else if (fstate == 3){
9521 BrHXXRatio = (myNPbase->BrHbbRatio());
9522 dBrHXXRatio1 = BrHXXRatio - 1.0;
9523 dBrHXXRatio2 = 0.0;
9524 } else if (fstate == 4){
9525 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9526 dBrHXXRatio1 = BrHXXRatio - 1.0;
9527 dBrHXXRatio2 = 0.0;
9528 } else {
9529 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9530 }
9531
9532 //-- Production x Decay:
9533 if ((this->getModel()).isModelLinearized()){
9534 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9535 } else if((this->getModel()).isModelNPquadratic()){
9536 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9537 } else {
9538 return weight*(muProd)*(BrHXXRatio);
9539 }
9540
9541
9542}
9543
9544// -----------------------------------------------------------------------------
9545
9546STXS12_qqHqq_mjj350_Inf_Nj2::STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9547: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9548{
9549 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9550 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
9551
9552}
9553
9555{
9556 //-- Production:
9557 double weight = 1.0; //If normalized to the SM
9558 //Since adding bins, include partial weigths of SM_predictions
9559 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9560
9561 double muProd = (0.53537*myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(sqrt_s)
9567 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
9568
9569 double muProd1 = muProd - 1.;
9570 double muProd2 = 0.0;
9571
9572 //-- Decay:
9573 double BrHXXRatio = 1.0;
9574 double dBrHXXRatio1 = 0.0;
9575 double dBrHXXRatio2 = 0.0;
9576 if (fstate==0){
9577 // Use for Cross-section [pb] with no Higgs-boson decay
9578 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9579 } else if (fstate == 1){
9580 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9581 dBrHXXRatio1 = BrHXXRatio - 1.0;
9582 dBrHXXRatio2 = 0.0;
9583 } else if (fstate == 2){
9584 BrHXXRatio = (myNPbase->BrHgagaRatio());
9585 dBrHXXRatio1 = BrHXXRatio - 1.0;
9586 dBrHXXRatio2 = 0.0;
9587 } else if (fstate == 3){
9588 BrHXXRatio = (myNPbase->BrHbbRatio());
9589 dBrHXXRatio1 = BrHXXRatio - 1.0;
9590 dBrHXXRatio2 = 0.0;
9591 } else if (fstate == 4){
9592 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9593 dBrHXXRatio1 = BrHXXRatio - 1.0;
9594 dBrHXXRatio2 = 0.0;
9595 } else if (fstate == 5){
9596 BrHXXRatio = (myNPbase->BrHtautauRatio());
9597 dBrHXXRatio1 = BrHXXRatio - 1.0;
9598 dBrHXXRatio2 = 0.0;
9599 } else {
9600 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9601 }
9602
9603
9604
9605
9606 //-- Production x Decay:
9607 if ((this->getModel()).isModelLinearized()){
9608// std::cout<<"\033[1;31m CHECK IF LINEAR \033[0m" << std::endl;
9609 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9610 } else if((this->getModel()).isModelNPquadratic()){
9611// std::cout<<"\033[1;31m CHECK IF QUADRATIC \033[0m" << std::endl;
9612 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9613 } else {
9614// std::cout<<"\033[1;31m CHECK IF NEITHER LINEAR NOR QUADRATIC \033[0m" << std::endl;
9615 return weight*(muProd)*(BrHXXRatio);
9616 }
9617
9618}
9619
9620// -----------------------------------------------------------------------------
9621
9622STXS12_qqHlv_pTV0_75::STXS12_qqHlv_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9623: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9624{
9625 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9626 throw std::runtime_error("STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
9627
9628}
9629
9631{
9632 //-- Production:
9633 double weight = 1.0; //If normalized to the SM
9634 double muProd = myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s);
9635 double muProd1 = muProd -1.0;
9636 double muProd2 = 0.0;
9637
9638 //-- Decay:
9639 double BrHXXRatio = 1.0;
9640 double dBrHXXRatio1 = 0.0;
9641 double dBrHXXRatio2 = 0.0;
9642 if (fstate==0){
9643 // Use for Cross-section [pb] with no Higgs-boson decay
9644 weight = 0.21509; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9645 } else if (fstate == 1){
9646 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9647 dBrHXXRatio1 = BrHXXRatio - 1.0;
9648 dBrHXXRatio2 = 0.0;
9649 } else if (fstate == 2){
9650 BrHXXRatio = (myNPbase->BrHgagaRatio());
9651 dBrHXXRatio1 = BrHXXRatio - 1.0;
9652 dBrHXXRatio2 = 0.0;
9653 } else if (fstate == 3){
9654 BrHXXRatio = (myNPbase->BrHbbRatio());
9655 dBrHXXRatio1 = BrHXXRatio - 1.0;
9656 dBrHXXRatio2 = 0.0;
9657 } else if (fstate == 4){
9658 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9659 dBrHXXRatio1 = BrHXXRatio - 1.0;
9660 dBrHXXRatio2 = 0.0;
9661 } else if (fstate == 5){
9662 BrHXXRatio = (myNPbase->BrHtautauRatio());
9663 dBrHXXRatio1 = BrHXXRatio - 1.0;
9664 dBrHXXRatio2 = 0.0;
9665 } else {
9666 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9667 }
9668
9669 //-- Production x Decay:
9670 if ((this->getModel()).isModelLinearized()){
9671 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9672 } else if((this->getModel()).isModelNPquadratic()){
9673 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9674 } else {
9675 return weight*(muProd)*(BrHXXRatio);
9676 }
9677
9678}
9679
9680// -----------------------------------------------------------------------------
9681
9682STXS12_qqHlv_pTV75_150::STXS12_qqHlv_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9683: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9684{
9685 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9686 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
9687
9688}
9689
9691{
9692 //-- Production:
9693 double weight = 1.0; //If normalized to the SM
9694 double muProd = myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s);
9695 double muProd1 = muProd -1.0;
9696 double muProd2 = 0.0;
9697
9698 //-- Decay:
9699 double BrHXXRatio = 1.0;
9700 double dBrHXXRatio1 = 0.0;
9701 double dBrHXXRatio2 = 0.0;
9702 if (fstate==0){
9703 // Use for Cross-section [pb] with no Higgs-boson decay
9704 weight = 0.13440; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9705 } else if (fstate == 1){
9706 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9707 dBrHXXRatio1 = BrHXXRatio - 1.0;
9708 dBrHXXRatio2 = 0.0;
9709 } else if (fstate == 2){
9710 BrHXXRatio = (myNPbase->BrHgagaRatio());
9711 dBrHXXRatio1 = BrHXXRatio - 1.0;
9712 dBrHXXRatio2 = 0.0;
9713 } else if (fstate == 3){
9714 BrHXXRatio = (myNPbase->BrHbbRatio());
9715 dBrHXXRatio1 = BrHXXRatio - 1.0;
9716 dBrHXXRatio2 = 0.0;
9717 } else if (fstate == 4){
9718 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9719 dBrHXXRatio1 = BrHXXRatio - 1.0;
9720 dBrHXXRatio2 = 0.0;
9721 } else if (fstate == 5){
9722 BrHXXRatio = (myNPbase->BrHtautauRatio());
9723 dBrHXXRatio1 = BrHXXRatio - 1.0;
9724 dBrHXXRatio2 = 0.0;
9725 } else {
9726 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
9727 }
9728
9729 //-- Production x Decay:
9730 if ((this->getModel()).isModelLinearized()){
9731 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9732 } else if((this->getModel()).isModelNPquadratic()){
9733 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9734 } else {
9735 return weight*(muProd)*(BrHXXRatio);
9736 }
9737
9738}
9739
9740// -----------------------------------------------------------------------------
9741
9742//AG:STXS2024
9743STXS12_qqHlv_pTV150_250_Nj0::STXS12_qqHlv_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9744: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9745{
9746 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9747 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
9748
9749}
9750
9752{
9753 //-- Production:
9754 double weight = 1.0; //If normalized to the SM
9756 double muProd1 = myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) - 1.0;
9757 double muProd2 = 0.0;
9758
9759 //-- Decay:
9760 double BrHXXRatio = 1.0;
9761 double dBrHXXRatio1 = 0.0;
9762 double dBrHXXRatio2 = 0.0;
9763 if (fstate==0){
9764 // Use for Cross-section [pb] with no Higgs-boson decay
9765 weight = 0.04117; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9766 } else if (fstate == 1){
9767 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9768 dBrHXXRatio1 = BrHXXRatio - 1.0;
9769 dBrHXXRatio2 = 0.0;
9770 } else if (fstate == 2){
9771 BrHXXRatio = (myNPbase->BrHgagaRatio());
9772 dBrHXXRatio1 = BrHXXRatio - 1.0;
9773 dBrHXXRatio2 = 0.0;
9774 } else if (fstate == 3){
9775 BrHXXRatio = (myNPbase->BrHbbRatio());
9776 dBrHXXRatio1 = BrHXXRatio - 1.0;
9777 dBrHXXRatio2 = 0.0;
9778 } else if (fstate == 4){
9779 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9780 dBrHXXRatio1 = BrHXXRatio - 1.0;
9781 dBrHXXRatio2 = 0.0;
9782 } else if (fstate == 5){
9783 BrHXXRatio = (myNPbase->BrHtautauRatio());
9784 dBrHXXRatio1 = BrHXXRatio - 1.0;
9785 dBrHXXRatio2 = 0.0;
9786 } else {
9787 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9788 }
9789
9790 //-- Production x Decay:
9791 if ((this->getModel()).isModelLinearized()){
9792 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9793 } else if((this->getModel()).isModelNPquadratic()){
9794 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9795 } else {
9796 return weight*(muProd)*(BrHXXRatio);
9797 }
9798
9799
9800}
9801
9802// -----------------------------------------------------------------------------
9803
9804STXS12_qqHlv_pTV150_250_Nj1::STXS12_qqHlv_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9805: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9806{
9807 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9808 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
9809
9810}
9811
9813{
9814 double BrHXXRatio = 1.0;
9815 if (fstate == 1){
9816 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9817 } else if (fstate == 2){
9818 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9819 } else if (fstate == 3){
9820 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9821 } else if (fstate == 4){
9822 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9823 } else {
9824 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
9825 }
9826
9827 if ((this->getModel()).isModelLinearized()) {
9828 return ((myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
9829 } else {
9830 return (myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
9831 }
9832}
9833
9834// -----------------------------------------------------------------------------
9835
9836STXS12_qqHlv_pTV250_Inf::STXS12_qqHlv_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9837: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9838{
9839 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9840 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
9841
9842}
9843
9845{
9846 double BrHXXRatio = 1.0;
9847 if (fstate == 1){
9848 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9849 } else if (fstate == 2){
9850 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9851 } else if (fstate == 3){
9852 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9853 } else if (fstate == 4){
9854 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9855 } else {
9856 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
9857 }
9858
9859 if ((this->getModel()).isModelLinearized()) {
9860 return ((myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
9861 } else {
9862 return (myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s))*(BrHXXRatio);
9863 }
9864}
9865
9866// -----------------------------------------------------------------------------
9867
9868//AG:STXS2024
9869STXS12_qqHlv_pTV0_150::STXS12_qqHlv_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9870: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9871{
9872 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9873 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
9874
9875}
9876
9878{
9879 //-- Production:
9880 double weight = 1.0; //If normalized to the SM
9881 //Since adding bins, include partial weigths of SM_predictions
9882 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9883 double muProd = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s))
9884 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s))/(0.21509+0.13440));
9885 double muProd1 = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
9886 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)/(0.21509+0.13440));
9887 double muProd2 = 0.0;
9888
9889 //-- Decay:
9890 double BrHXXRatio = 1.0;
9891 double dBrHXXRatio1 = 0.0;
9892 double dBrHXXRatio2 = 0.0;
9893 if (fstate==0){
9894 // Use for Cross-section [pb] with no Higgs-boson decay
9895 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9896 } else if (fstate == 1){
9897 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9898 dBrHXXRatio1 = BrHXXRatio - 1.0;
9899 dBrHXXRatio2 = 0.0;
9900 } else if (fstate == 2){
9901 BrHXXRatio = (myNPbase->BrHgagaRatio());
9902 dBrHXXRatio1 = BrHXXRatio - 1.0;
9903 dBrHXXRatio2 = 0.0;
9904 } else if (fstate == 3){
9905 BrHXXRatio = (myNPbase->BrHbbRatio());
9906 dBrHXXRatio1 = BrHXXRatio - 1.0;
9907 dBrHXXRatio2 = 0.0;
9908 } else if (fstate == 4){
9909 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9910 dBrHXXRatio1 = BrHXXRatio - 1.0;
9911 dBrHXXRatio2 = 0.0;
9912 } else {
9913 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
9914 }
9915
9916 //-- Production x Decay:
9917 if ((this->getModel()).isModelLinearized()){
9918 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9919 } else if((this->getModel()).isModelNPquadratic()){
9920 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9921 } else {
9922 return weight*(muProd)*(BrHXXRatio);
9923 }
9924
9925
9926}
9927
9928// -----------------------------------------------------------------------------
9929
9930//AG:STXS2024
9931STXS12_qqHlv_pTV150_Inf::STXS12_qqHlv_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9932: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9933{
9934 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9935 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
9936
9937}
9938
9940{
9941 //-- Production:
9942 double weight = 1.0; //If normalized to the SM
9943 //Since adding bins, include partial weigths of SM_predictions
9944 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9945 double muProd = (0.04117 * myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
9947 + 0.00214 * myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) )/(0.04117+0.01004+0.00214);
9948 double muProd1 = (0.04117 * (myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) -1.0)
9949 + 0.01004 * (myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
9950 + 0.00214 * (myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0) )/(0.04117+0.01004+0.00214);
9951 double muProd2 = 0.0;
9952
9953 //-- Decay:
9954 double BrHXXRatio = 1.0;
9955 double dBrHXXRatio1 = 0.0;
9956 double dBrHXXRatio2 = 0.0;
9957 if (fstate==0){
9958 // Use for Cross-section [pb] with no Higgs-boson decay
9959 weight = 1.0 ;
9960 } else if (fstate == 1){
9961 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9962 dBrHXXRatio1 = BrHXXRatio - 1.0;
9963 dBrHXXRatio2 = 0.0;
9964 } else if (fstate == 2){
9965 BrHXXRatio = (myNPbase->BrHgagaRatio());
9966 dBrHXXRatio1 = BrHXXRatio - 1.0;
9967 dBrHXXRatio2 = 0.0;
9968 } else if (fstate == 3){
9969 BrHXXRatio = (myNPbase->BrHbbRatio());
9970 dBrHXXRatio1 = BrHXXRatio - 1.0;
9971 dBrHXXRatio2 = 0.0;
9972 } else if (fstate == 4){
9973 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9974 dBrHXXRatio1 = BrHXXRatio - 1.0;
9975 dBrHXXRatio2 = 0.0;
9976 } else {
9977 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
9978 }
9979
9980 //-- Production x Decay:
9981 if ((this->getModel()).isModelLinearized()){
9982 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9983 } else if((this->getModel()).isModelNPquadratic()){
9984 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9985 } else {
9986 return weight*(muProd)*(BrHXXRatio);
9987 }
9988
9989
9990}
9991
9992// -----------------------------------------------------------------------------
9993
9994//AG:STXS2024
9995STXS12_qqHlv_pTV250_400::STXS12_qqHlv_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9996: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9997{
9998 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9999 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
10000
10001}
10002
10004{
10005 //-- Production:
10006 double weight = 1.0; //If normalized to the SM
10007 double muProd = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s) ;
10008 double muProd1 = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0 ;
10009 double muProd2 = 0.0;
10010
10011 //-- Decay:
10012 double BrHXXRatio = 1.0;
10013 double dBrHXXRatio1 = 0.0;
10014 double dBrHXXRatio2 = 0.0;
10015 if (fstate==0){
10016 // Use for Cross-section [pb] with no Higgs-boson decay
10017 weight =0.01004 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10018 } else if (fstate == 1){
10019 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10020 dBrHXXRatio1 = BrHXXRatio - 1.0;
10021 dBrHXXRatio2 = 0.0;
10022 } else if (fstate == 2){
10023 BrHXXRatio = (myNPbase->BrHgagaRatio());
10024 dBrHXXRatio1 = BrHXXRatio - 1.0;
10025 dBrHXXRatio2 = 0.0;
10026 } else if (fstate == 3){
10027 BrHXXRatio = (myNPbase->BrHbbRatio());
10028 dBrHXXRatio1 = BrHXXRatio - 1.0;
10029 dBrHXXRatio2 = 0.0;
10030 } else if (fstate == 4){
10031 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10032 dBrHXXRatio1 = BrHXXRatio - 1.0;
10033 dBrHXXRatio2 = 0.0;
10034 } else {
10035 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
10036 }
10037
10038 //-- Production x Decay:
10039 if ((this->getModel()).isModelLinearized()){
10040 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10041 } else if((this->getModel()).isModelNPquadratic()){
10042 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10043 } else {
10044 return weight*(muProd)*(BrHXXRatio);
10045 }
10046
10047
10048}
10049
10050// -----------------------------------------------------------------------------
10051
10052//AG:STXS2024
10053STXS12_qqHlv_pTV400_Inf::STXS12_qqHlv_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10054: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10055{
10056 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10057 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
10058
10059}
10060
10062{
10063 //-- Production:
10064 double weight = 1.0; //If normalized to the SM
10065 double muProd = myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) ;
10066 double muProd1 = muProd-1.0 ;
10067 double muProd2 = 0.0;
10068
10069 //-- Decay:
10070 double BrHXXRatio = 1.0;
10071 double dBrHXXRatio1 = 0.0;
10072 double dBrHXXRatio2 = 0.0;
10073 if (fstate==0){
10074 // Use for Cross-section [pb] with no Higgs-boson decay
10075 weight =0.00214 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10076 } else if (fstate == 1){
10077 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10078 dBrHXXRatio1 = BrHXXRatio - 1.0;
10079 dBrHXXRatio2 = 0.0;
10080 } else if (fstate == 2){
10081 BrHXXRatio = (myNPbase->BrHgagaRatio());
10082 dBrHXXRatio1 = BrHXXRatio - 1.0;
10083 dBrHXXRatio2 = 0.0;
10084 } else if (fstate == 3){
10085 BrHXXRatio = (myNPbase->BrHbbRatio());
10086 dBrHXXRatio1 = BrHXXRatio - 1.0;
10087 dBrHXXRatio2 = 0.0;
10088 } else if (fstate == 4){
10089 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10090 dBrHXXRatio1 = BrHXXRatio - 1.0;
10091 dBrHXXRatio2 = 0.0;
10092 } else {
10093 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
10094 }
10095
10096 //-- Production x Decay:
10097 if ((this->getModel()).isModelLinearized()){
10098 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10099 } else if((this->getModel()).isModelNPquadratic()){
10100 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10101 } else {
10102 return weight*(muProd)*(BrHXXRatio);
10103 }
10104
10105
10106}
10107
10108
10109// -----------------------------------------------------------------------------
10110
10111STXS12_qqHll_pTV0_75::STXS12_qqHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10112: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10113{
10114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10115 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
10116
10117}
10118
10120{
10121 double BrHXXRatio = 1.0;
10122 if (fstate == 1){
10123 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10124 } else if (fstate == 2){
10125 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10126 } else if (fstate == 3){
10127 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10128 } else if (fstate == 4){
10129 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10130 } else {
10131 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
10132 }
10133
10134 if ((this->getModel()).isModelLinearized()) {
10135 return ((myNPbase->STXS12_qqHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
10136 } else {
10137 return (myNPbase->STXS12_qqHll_pTV0_75(sqrt_s))*(BrHXXRatio);
10138 }
10139}
10140
10141// -----------------------------------------------------------------------------
10142
10143//AG:STXS2024
10144STXS12_qqHll_pTV75_150::STXS12_qqHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10145: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10146{
10147 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10148 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
10149
10150}
10151
10153{
10154 //-- Production:
10155 double weight = 1.0; //If normalized to the SM
10156 double muProd = myNPbase->STXS12_qqHll_pTV75_150(sqrt_s);
10157 double muProd1 = muProd -1.0;
10158 double muProd2 = 0.0;
10159
10160 //-- Decay:
10161 double BrHXXRatio = 1.0;
10162 double dBrHXXRatio1 = 0.0;
10163 double dBrHXXRatio2 = 0.0;
10164 if (fstate==0){
10165 // Use for Cross-section [pb] with no Higgs-boson decay
10166 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10167 } else if (fstate == 1){
10168 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10169 dBrHXXRatio1 = BrHXXRatio - 1.0;
10170 dBrHXXRatio2 = 0.0;
10171 } else if (fstate == 2){
10172 BrHXXRatio = (myNPbase->BrHgagaRatio());
10173 dBrHXXRatio1 = BrHXXRatio - 1.0;
10174 dBrHXXRatio2 = 0.0;
10175 } else if (fstate == 3){
10176 BrHXXRatio = (myNPbase->BrHbbRatio());
10177 dBrHXXRatio1 = BrHXXRatio - 1.0;
10178 dBrHXXRatio2 = 0.0;
10179 } else if (fstate == 4){
10180 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10181 dBrHXXRatio1 = BrHXXRatio - 1.0;
10182 dBrHXXRatio2 = 0.0;
10183 } else {
10184 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
10185 }
10186
10187 //-- Production x Decay:
10188 if ((this->getModel()).isModelLinearized()){
10189 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10190 } else if((this->getModel()).isModelNPquadratic()){
10191 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10192 } else {
10193 return weight*(muProd)*(BrHXXRatio);
10194 }
10195
10196
10197}
10198
10199// -----------------------------------------------------------------------------
10200
10201//AG:STXS2024
10202STXS12_qqHll_pTV150_250_Nj0::STXS12_qqHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10203: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10204{
10205 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10206 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10207
10208}
10209
10211{
10212 //-- Production:
10213 double weight = 1.0; //If normalized to the SM
10215 double muProd1 = muProd -1.0;
10216 double muProd2 = 0.0;
10217
10218 //-- Decay:
10219 double BrHXXRatio = 1.0;
10220 double dBrHXXRatio1 = 0.0;
10221 double dBrHXXRatio2 = 0.0;
10222 if (fstate==0){
10223 // Use for Cross-section [pb] with no Higgs-boson decay
10224 weight = 0.03223 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10225 } else if (fstate == 1){
10226 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10227 dBrHXXRatio1 = BrHXXRatio - 1.0;
10228 dBrHXXRatio2 = 0.0;
10229 } else if (fstate == 2){
10230 BrHXXRatio = (myNPbase->BrHgagaRatio());
10231 dBrHXXRatio1 = BrHXXRatio - 1.0;
10232 dBrHXXRatio2 = 0.0;
10233 } else if (fstate == 3){
10234 BrHXXRatio = (myNPbase->BrHbbRatio());
10235 dBrHXXRatio1 = BrHXXRatio - 1.0;
10236 dBrHXXRatio2 = 0.0;
10237 } else if (fstate == 4){
10238 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10239 dBrHXXRatio1 = BrHXXRatio - 1.0;
10240 dBrHXXRatio2 = 0.0;
10241 } else {
10242 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
10243 }
10244
10245 //-- Production x Decay:
10246 if ((this->getModel()).isModelLinearized()){
10247 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10248 } else if((this->getModel()).isModelNPquadratic()){
10249 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10250 } else {
10251 return weight*(muProd)*(BrHXXRatio);
10252 }
10253
10254}
10255
10256// -----------------------------------------------------------------------------
10257
10258STXS12_qqHll_pTV150_250_Nj1::STXS12_qqHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10259: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10260{
10261 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10262 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10263
10264}
10265
10267{
10268 double BrHXXRatio = 1.0;
10269 if (fstate == 1){
10270 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10271 } else if (fstate == 2){
10272 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10273 } else if (fstate == 3){
10274 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10275 } else if (fstate == 4){
10276 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10277 } else {
10278 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10279 }
10280
10281 if ((this->getModel()).isModelLinearized()) {
10282 return ((myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10283 } else {
10284 return (myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10285 }
10286}
10287
10288// -----------------------------------------------------------------------------
10289
10290STXS12_qqHll_pTV250_Inf::STXS12_qqHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10291: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10292{
10293 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10294 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
10295
10296}
10297
10299{
10300 double BrHXXRatio = 1.0;
10301 if (fstate == 1){
10302 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10303 } else if (fstate == 2){
10304 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10305 } else if (fstate == 3){
10306 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10307 } else if (fstate == 4){
10308 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10309 } else {
10310 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
10311 }
10312
10313 if ((this->getModel()).isModelLinearized()) {
10314 return ((myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10315 } else {
10316 return (myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10317 }
10318}
10319
10320
10321// -----------------------------------------------------------------------------
10322
10323//AG:STXS2024
10324STXS12_qqHll_pTV0_150::STXS12_qqHll_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10325: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10326{
10327 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10328 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
10329
10330}
10331
10333{
10334 //-- Production:
10335 double weight = 1.0; //If normalized to the SM
10336 double muProd = myNPbase->STXS12_qqHll_pTV0_150(sqrt_s);
10337 double muProd1 = muProd -1.0;
10338 double muProd2 = 0.0;
10339
10340 //-- Decay:
10341 double BrHXXRatio = 1.0;
10342 double dBrHXXRatio1 = 0.0;
10343 double dBrHXXRatio2 = 0.0;
10344 if (fstate==0){
10345 // Use for Cross-section [pb] with no Higgs-boson decay
10346 weight = 0.19845 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10347 } else if (fstate == 1){
10348 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10349 dBrHXXRatio1 = BrHXXRatio - 1.0;
10350 dBrHXXRatio2 = 0.0;
10351 } else if (fstate == 2){
10352 BrHXXRatio = (myNPbase->BrHgagaRatio());
10353 dBrHXXRatio1 = BrHXXRatio - 1.0;
10354 dBrHXXRatio2 = 0.0;
10355 } else if (fstate == 3){
10356 BrHXXRatio = (myNPbase->BrHbbRatio());
10357 dBrHXXRatio1 = BrHXXRatio - 1.0;
10358 dBrHXXRatio2 = 0.0;
10359 } else if (fstate == 4){
10360 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10361 dBrHXXRatio1 = BrHXXRatio - 1.0;
10362 dBrHXXRatio2 = 0.0;
10363 } else {
10364 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
10365 }
10366
10367 //-- Production x Decay:
10368 if ((this->getModel()).isModelLinearized()){
10369 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10370 } else if((this->getModel()).isModelNPquadratic()){
10371 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10372 } else {
10373 return weight*(muProd)*(BrHXXRatio);
10374 }
10375
10376}
10377
10378// -----------------------------------------------------------------------------
10379
10380//AG:STXS2024
10381STXS12_qqHll_pTV250_400::STXS12_qqHll_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10382: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10383{
10384 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10385 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
10386
10387}
10388
10390{
10391 //-- Production:
10392 double weight = 1.0; //If normalized to the SM
10393 double muProd = myNPbase->STXS12_qqHll_pTV250_400(sqrt_s);
10394 double muProd1 = muProd -1.0;
10395 double muProd2 = 0.0;
10396
10397 //-- Decay:
10398 double BrHXXRatio = 1.0;
10399 double dBrHXXRatio1 = 0.0;
10400 double dBrHXXRatio2 = 0.0;
10401 if (fstate==0){
10402 // Use for Cross-section [pb] with no Higgs-boson decay
10403 weight = 0.00715 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10404 } else if (fstate == 1){
10405 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10406 dBrHXXRatio1 = BrHXXRatio - 1.0;
10407 dBrHXXRatio2 = 0.0;
10408 } else if (fstate == 2){
10409 BrHXXRatio = (myNPbase->BrHgagaRatio());
10410 dBrHXXRatio1 = BrHXXRatio - 1.0;
10411 dBrHXXRatio2 = 0.0;
10412 } else if (fstate == 3){
10413 BrHXXRatio = (myNPbase->BrHbbRatio());
10414 dBrHXXRatio1 = BrHXXRatio - 1.0;
10415 dBrHXXRatio2 = 0.0;
10416 } else if (fstate == 4){
10417 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10418 dBrHXXRatio1 = BrHXXRatio - 1.0;
10419 dBrHXXRatio2 = 0.0;
10420 } else {
10421 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
10422 }
10423
10424 //-- Production x Decay:
10425 if ((this->getModel()).isModelLinearized()){
10426 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10427 } else if((this->getModel()).isModelNPquadratic()){
10428 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10429 } else {
10430 return weight*(muProd)*(BrHXXRatio);
10431 }
10432
10433}
10434
10435// -----------------------------------------------------------------------------
10436
10437//AG:STXS2024
10438STXS12_qqHll_pTV400_Inf::STXS12_qqHll_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10439: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10440{
10441 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10442 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
10443
10444}
10445
10447{
10448 //-- Production:
10449 double weight = 1.0; //If normalized to the SM
10450 double muProd = myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s);
10451 double muProd1 = muProd -1.0;
10452 double muProd2 = 0.0;
10453
10454 //-- Decay:
10455 double BrHXXRatio = 1.0;
10456 double dBrHXXRatio1 = 0.0;
10457 double dBrHXXRatio2 = 0.0;
10458 if (fstate==0){
10459 // Use for Cross-section [pb] with no Higgs-boson decay
10460 weight = 0.00126 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10461 } else if (fstate == 1){
10462 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10463 dBrHXXRatio1 = BrHXXRatio - 1.0;
10464 dBrHXXRatio2 = 0.0;
10465 } else if (fstate == 2){
10466 BrHXXRatio = (myNPbase->BrHgagaRatio());
10467 dBrHXXRatio1 = BrHXXRatio - 1.0;
10468 dBrHXXRatio2 = 0.0;
10469 } else if (fstate == 3){
10470 BrHXXRatio = (myNPbase->BrHbbRatio());
10471 dBrHXXRatio1 = BrHXXRatio - 1.0;
10472 dBrHXXRatio2 = 0.0;
10473 } else if (fstate == 4){
10474 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10475 dBrHXXRatio1 = BrHXXRatio - 1.0;
10476 dBrHXXRatio2 = 0.0;
10477 } else {
10478 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
10479 }
10480
10481 //-- Production x Decay:
10482 if ((this->getModel()).isModelLinearized()){
10483 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10484 } else if((this->getModel()).isModelNPquadratic()){
10485 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10486 } else {
10487 return weight*(muProd)*(BrHXXRatio);
10488 }
10489
10490
10491}
10492
10493// -----------------------------------------------------------------------------
10494
10495//AG:STXS2024
10496STXS12_qqHll_pTV150_Inf::STXS12_qqHll_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10497: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10498{
10499 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10500 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
10501
10502}
10503
10505{
10506 //-- Production:
10507 double weight = 1.0; //If normalized to the SM
10508 //Since adding bins, include partial weigths of SM_predictions
10509 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10510 double muProd = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s))
10512 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)) )/(0.03223+0.00715+0.00126);
10513 double muProd1 = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s)-1.0)
10514 + 0.00715*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10515 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )/(0.03223+0.00715+0.00126);
10516 double muProd2 = 0.0;
10517
10518 //-- Decay:
10519 double BrHXXRatio = 1.0;
10520 double dBrHXXRatio1 = 0.0;
10521 double dBrHXXRatio2 = 0.0;
10522 if (fstate==0){
10523 weight = 1.0 ;
10524 } else if (fstate == 1){
10525 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10526 dBrHXXRatio1 = BrHXXRatio - 1.0;
10527 dBrHXXRatio2 = 0.0;
10528 } else if (fstate == 2){
10529 BrHXXRatio = (myNPbase->BrHgagaRatio());
10530 dBrHXXRatio1 = BrHXXRatio - 1.0;
10531 dBrHXXRatio2 = 0.0;
10532 } else if (fstate == 3){
10533 BrHXXRatio = (myNPbase->BrHbbRatio());
10534 dBrHXXRatio1 = BrHXXRatio - 1.0;
10535 dBrHXXRatio2 = 0.0;
10536 } else if (fstate == 4){
10537 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10538 dBrHXXRatio1 = BrHXXRatio - 1.0;
10539 dBrHXXRatio2 = 0.0;
10540 } else {
10541 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
10542 }
10543
10544 //-- Production x Decay:
10545 if ((this->getModel()).isModelLinearized()){
10546 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10547 } else if((this->getModel()).isModelNPquadratic()){
10548 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10549 } else {
10550 return weight*(muProd)*(BrHXXRatio);
10551 }
10552
10553
10554}
10555
10556// -----------------------------------------------------------------------------
10557
10558//AG:STXS2024
10559STXS12_VHlep::STXS12_VHlep(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10560: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10561{
10562 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10563 throw std::runtime_error("STXS12_VHlep called with a class whose parent is not NPbase");
10564
10565}
10566
10568{
10569 //-- Production:
10570 double weight = 1.0; //If normalized to the SM
10571 //Since adding bins, include partial weigths of SM_predictions
10572 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10573 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
10582 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10583 double muProd1 = ( 0.71256*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10584 + 0.06739*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)
10586 + 0.01127*(myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10587 + 0.00339*(myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0)
10588 + 0.07934*(myNPbase->STXS12_qqHll_pTV0_150(sqrt_s) -1.0)
10590 + 0.00746*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10591 + 0.00043*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )
10592 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10593 double muProd2 = 0.0;
10594
10595 //-- Decay:
10596 double BrHXXRatio = 1.0;
10597 double dBrHXXRatio1 = 0.0;
10598 double dBrHXXRatio2 = 0.0;
10599 if (fstate==0){
10600 weight = 1.0;
10601 } else if (fstate == 1){
10602 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10603 dBrHXXRatio1 = BrHXXRatio - 1.0;
10604 dBrHXXRatio2 = 0.0;
10605 } else if (fstate == 2){
10606 BrHXXRatio = (myNPbase->BrHgagaRatio());
10607 dBrHXXRatio1 = BrHXXRatio - 1.0;
10608 dBrHXXRatio2 = 0.0;
10609 } else if (fstate == 3){
10610 BrHXXRatio = (myNPbase->BrHbbRatio());
10611 dBrHXXRatio1 = BrHXXRatio - 1.0;
10612 dBrHXXRatio2 = 0.0;
10613 } else if (fstate == 4){
10614 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10615 dBrHXXRatio1 = BrHXXRatio - 1.0;
10616 dBrHXXRatio2 = 0.0;
10617 } else if (fstate == 5){
10618 BrHXXRatio = (myNPbase->BrHtautauRatio());
10619 dBrHXXRatio1 = BrHXXRatio - 1.0;
10620 dBrHXXRatio2 = 0.0;
10621 } else if (fstate == 6){
10622 BrHXXRatio = (myNPbase->BrHWWRatio());
10623 dBrHXXRatio1 = BrHXXRatio - 1.0;
10624 dBrHXXRatio2 = 0.0;
10625 } else if (fstate == 7){
10626 BrHXXRatio = (myNPbase->BrHZZRatio());
10627 dBrHXXRatio1 = BrHXXRatio - 1.0;
10628 dBrHXXRatio2 = 0.0;
10629 } else {
10630 throw std::runtime_error("STXS12_VHlep called with invalid argument for final state in fstate_i");
10631 }
10632
10633 //-- Production x Decay:
10634 if ((this->getModel()).isModelLinearized()){
10635 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10636 } else if((this->getModel()).isModelNPquadratic()){
10637 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10638 } else {
10639 return weight*(muProd)*(BrHXXRatio);
10640 }
10641
10642
10643}
10644
10645// -----------------------------------------------------------------------------
10646
10647//AG:STXS2024
10648STXS12_ttH_pTH0_60::STXS12_ttH_pTH0_60(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10649: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10650{
10651 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10652 throw std::runtime_error("STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
10653
10654}
10655
10657{
10658 //-- Production:
10659 double weight = 1.0; //If normalized to the SM
10660 double muProd = myNPbase->STXS12_ttH_pTH0_60(sqrt_s) ;
10661 double muProd1 = muProd -1.0;
10662 double muProd2 = 0.0;
10663
10664 //-- Decay:
10665 double BrHXXRatio = 1.0;
10666 double dBrHXXRatio1 = 0.0;
10667 double dBrHXXRatio2 = 0.0;
10668 if (fstate==0){
10669 // Use for Cross-section [pb] with no Higgs-boson decay
10670 weight = 0.11821; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10671 } else if (fstate == 1){
10672 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10673 dBrHXXRatio1 = BrHXXRatio - 1.0;
10674 dBrHXXRatio2 = 0.0;
10675 } else if (fstate == 2){
10676 BrHXXRatio = (myNPbase->BrHgagaRatio());
10677 dBrHXXRatio1 = BrHXXRatio - 1.0;
10678 dBrHXXRatio2 = 0.0;
10679 } else if (fstate == 3){
10680 BrHXXRatio = (myNPbase->BrHbbRatio());
10681 dBrHXXRatio1 = BrHXXRatio - 1.0;
10682 dBrHXXRatio2 = 0.0;
10683 } else if (fstate == 4){
10684 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10685 dBrHXXRatio1 = BrHXXRatio - 1.0;
10686 dBrHXXRatio2 = 0.0;
10687 } else {
10688 throw std::runtime_error("STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
10689 }
10690
10691 //-- Production x Decay:
10692 if ((this->getModel()).isModelLinearized()){
10693 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10694 } else if((this->getModel()).isModelNPquadratic()){
10695 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10696 } else {
10697 return weight*(muProd)*(BrHXXRatio);
10698 }
10699
10700
10701}
10702
10703// -----------------------------------------------------------------------------
10704
10705//AG:STXS2024
10706STXS12_ttH_pTH60_120::STXS12_ttH_pTH60_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10707: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10708{
10709 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10710 throw std::runtime_error("STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
10711
10712}
10713
10715{
10716 //-- Production:
10717 double weight = 1.0; //If normalized to the SM
10718 double muProd = myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ;
10719 double muProd1 = muProd -1.0;
10720 double muProd2 = 0.0;
10721
10722 //-- Decay:
10723 double BrHXXRatio = 1.0;
10724 double dBrHXXRatio1 = 0.0;
10725 double dBrHXXRatio2 = 0.0;
10726 if (fstate==0){
10727 // Use for Cross-section [pb] with no Higgs-boson decay
10728 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10729 } else if (fstate == 1){
10730 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10731 dBrHXXRatio1 = BrHXXRatio - 1.0;
10732 dBrHXXRatio2 = 0.0;
10733 } else if (fstate == 2){
10734 BrHXXRatio = (myNPbase->BrHgagaRatio());
10735 dBrHXXRatio1 = BrHXXRatio - 1.0;
10736 dBrHXXRatio2 = 0.0;
10737 } else if (fstate == 3){
10738 BrHXXRatio = (myNPbase->BrHbbRatio());
10739 dBrHXXRatio1 = BrHXXRatio - 1.0;
10740 dBrHXXRatio2 = 0.0;
10741 } else if (fstate == 4){
10742 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10743 dBrHXXRatio1 = BrHXXRatio - 1.0;
10744 dBrHXXRatio2 = 0.0;
10745 } else {
10746 throw std::runtime_error("STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
10747 }
10748
10749 //-- Production x Decay:
10750 if ((this->getModel()).isModelLinearized()){
10751 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10752 } else if((this->getModel()).isModelNPquadratic()){
10753 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10754 } else {
10755 return weight*(muProd)*(BrHXXRatio);
10756 }
10757
10758}
10759
10760// -----------------------------------------------------------------------------
10761
10762//AG:STXS2024
10763STXS12_ttH_pTH0_120::STXS12_ttH_pTH0_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10764: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10765{
10766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10767 throw std::runtime_error("STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
10768
10769}
10770
10772{
10773 //-- Production:
10774 double weight = 1.0; //If normalized to the SM
10775 //Since adding bins, include partial weigths of SM_predictions
10776 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10777 double muProd = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) )
10778 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ) )/(0.11821+0.17813);
10779 double muProd1 = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) -1.0)
10780 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0 ) )/(0.11821+0.17813);;
10781 double muProd2 = 0.0;
10782
10783 //-- Decay:
10784 double BrHXXRatio = 1.0;
10785 double dBrHXXRatio1 = 0.0;
10786 double dBrHXXRatio2 = 0.0;
10787 if (fstate==0){
10788 // Use for Cross-section [pb] with no Higgs-boson decay
10789 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10790 } else if (fstate == 1){
10791 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10792 dBrHXXRatio1 = BrHXXRatio - 1.0;
10793 dBrHXXRatio2 = 0.0;
10794 } else if (fstate == 2){
10795 BrHXXRatio = (myNPbase->BrHgagaRatio());
10796 dBrHXXRatio1 = BrHXXRatio - 1.0;
10797 dBrHXXRatio2 = 0.0;
10798 } else if (fstate == 3){
10799 BrHXXRatio = (myNPbase->BrHbbRatio());
10800 dBrHXXRatio1 = BrHXXRatio - 1.0;
10801 dBrHXXRatio2 = 0.0;
10802 } else if (fstate == 4){
10803 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10804 dBrHXXRatio1 = BrHXXRatio - 1.0;
10805 dBrHXXRatio2 = 0.0;
10806 } else {
10807 throw std::runtime_error("STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
10808 }
10809
10810 //-- Production x Decay:
10811 if ((this->getModel()).isModelLinearized()){
10812 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10813 } else if((this->getModel()).isModelNPquadratic()){
10814 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10815 } else {
10816 return weight*(muProd)*(BrHXXRatio);
10817 }
10818
10819}
10820
10821// -----------------------------------------------------------------------------
10822
10823//AG:STXS2024
10824STXS12_ttH_pTH120_200::STXS12_ttH_pTH120_200(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10825: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10826{
10827 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10828 throw std::runtime_error("STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
10829
10830}
10831
10833{
10834 //-- Production:
10835 double weight = 1.0; //If normalized to the SM
10836 double muProd = myNPbase->STXS12_ttH_pTH120_200(sqrt_s) ;
10837 double muProd1 = muProd -1.0;
10838 double muProd2 = 0.0;
10839
10840 //-- Decay:
10841 double BrHXXRatio = 1.0;
10842 double dBrHXXRatio1 = 0.0;
10843 double dBrHXXRatio2 = 0.0;
10844 if (fstate==0){
10845 // Use for Cross-section [pb] with no Higgs-boson decay
10846 weight = 0.12647; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10847 } else if (fstate == 1){
10848 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10849 dBrHXXRatio1 = BrHXXRatio - 1.0;
10850 dBrHXXRatio2 = 0.0;
10851 } else if (fstate == 2){
10852 BrHXXRatio = (myNPbase->BrHgagaRatio());
10853 dBrHXXRatio1 = BrHXXRatio - 1.0;
10854 dBrHXXRatio2 = 0.0;
10855 } else if (fstate == 3){
10856 BrHXXRatio = (myNPbase->BrHbbRatio());
10857 dBrHXXRatio1 = BrHXXRatio - 1.0;
10858 dBrHXXRatio2 = 0.0;
10859 } else if (fstate == 4){
10860 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10861 dBrHXXRatio1 = BrHXXRatio - 1.0;
10862 dBrHXXRatio2 = 0.0;
10863 } else {
10864 throw std::runtime_error("STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
10865 }
10866
10867 //-- Production x Decay:
10868 if ((this->getModel()).isModelLinearized()){
10869 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10870 } else if((this->getModel()).isModelNPquadratic()){
10871 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10872 } else {
10873 return weight*(muProd)*(BrHXXRatio);
10874 }
10875
10876}
10877
10878// -----------------------------------------------------------------------------
10879
10880//AG:STXS2024
10881STXS12_ttH_pTH200_300::STXS12_ttH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10882: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10883{
10884 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10885 throw std::runtime_error("STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
10886
10887}
10888
10890{
10891 //-- Production:
10892 double weight = 1.0; //If normalized to the SM
10893 double muProd = myNPbase->STXS12_ttH_pTH200_300(sqrt_s) ;
10894 double muProd1 = muProd -1.0;
10895 double muProd2 = 0.0;
10896
10897 //-- Decay:
10898 double BrHXXRatio = 1.0;
10899 double dBrHXXRatio1 = 0.0;
10900 double dBrHXXRatio2 = 0.0;
10901 if (fstate==0){
10902 // Use for Cross-section [pb] with no Higgs-boson decay
10903 weight = 0.05263; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10904 } else if (fstate == 1){
10905 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10906 dBrHXXRatio1 = BrHXXRatio - 1.0;
10907 dBrHXXRatio2 = 0.0;
10908 } else if (fstate == 2){
10909 BrHXXRatio = (myNPbase->BrHgagaRatio());
10910 dBrHXXRatio1 = BrHXXRatio - 1.0;
10911 dBrHXXRatio2 = 0.0;
10912 } else if (fstate == 3){
10913 BrHXXRatio = (myNPbase->BrHbbRatio());
10914 dBrHXXRatio1 = BrHXXRatio - 1.0;
10915 dBrHXXRatio2 = 0.0;
10916 } else if (fstate == 4){
10917 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10918 dBrHXXRatio1 = BrHXXRatio - 1.0;
10919 dBrHXXRatio2 = 0.0;
10920 } else {
10921 throw std::runtime_error("STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
10922 }
10923
10924 //-- Production x Decay:
10925 if ((this->getModel()).isModelLinearized()){
10926 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10927 } else if((this->getModel()).isModelNPquadratic()){
10928 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10929 } else {
10930 return weight*(muProd)*(BrHXXRatio);
10931 }
10932
10933}
10934
10935// -----------------------------------------------------------------------------
10936
10937STXS12_ttH_pTH300_Inf::STXS12_ttH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10938: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10939{
10940 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10941 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
10942
10943}
10944
10946{
10947 //-- Production:
10948 double weight = 1.0; //If normalized to the SM
10949 double muProd = myNPbase->STXS12_ttH_pTH300_Inf(sqrt_s) ;
10950 double muProd1 = muProd -1.0;
10951 double muProd2 = 0.0;
10952
10953 //-- Decay:
10954 double BrHXXRatio = 1.0;
10955 double dBrHXXRatio1 = 0.0;
10956 double dBrHXXRatio2 = 0.0;
10957 if (fstate==0){
10958 // Use for Cross-section [pb] with no Higgs-boson decay
10959 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10960 } else if (fstate == 1){
10961 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10962 dBrHXXRatio1 = BrHXXRatio - 1.0;
10963 dBrHXXRatio2 = 0.0;
10964 } else if (fstate == 2){
10965 BrHXXRatio = (myNPbase->BrHgagaRatio());
10966 dBrHXXRatio1 = BrHXXRatio - 1.0;
10967 dBrHXXRatio2 = 0.0;
10968 } else if (fstate == 3){
10969 BrHXXRatio = (myNPbase->BrHbbRatio());
10970 dBrHXXRatio1 = BrHXXRatio - 1.0;
10971 dBrHXXRatio2 = 0.0;
10972 } else if (fstate == 4){
10973 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10974 dBrHXXRatio1 = BrHXXRatio - 1.0;
10975 dBrHXXRatio2 = 0.0;
10976 } else {
10977 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
10978 }
10979
10980 //-- Production x Decay:
10981 if ((this->getModel()).isModelLinearized()){
10982 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10983 } else if((this->getModel()).isModelNPquadratic()){
10984 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10985 } else {
10986 return weight*(muProd)*(BrHXXRatio);
10987 }
10988
10989
10990}
10991
10992// -----------------------------------------------------------------------------
10993
10994//AG:STXS2024
10995STXS12_ttH_pTH300_450::STXS12_ttH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10996: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10997{
10998 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10999 throw std::runtime_error("STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
11000
11001}
11002
11004{
11005 //-- Production:
11006 double weight = 1.0; //If normalized to the SM
11007 double muProd = myNPbase->STXS12_ttH_pTH300_450(sqrt_s);
11008 double muProd1 = muProd -1.0;
11009 double muProd2 = 0.0;
11010
11011 //-- Decay:
11012 double BrHXXRatio = 1.0;
11013 double dBrHXXRatio1 = 0.0;
11014 double dBrHXXRatio2 = 0.0;
11015 if (fstate==0){
11016 // Use for Cross-section [pb] with no Higgs-boson decay
11017 weight = 0.01903; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11018 } else if (fstate == 1){
11019 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11020 dBrHXXRatio1 = BrHXXRatio - 1.0;
11021 dBrHXXRatio2 = 0.0;
11022 } else if (fstate == 2){
11023 BrHXXRatio = (myNPbase->BrHgagaRatio());
11024 dBrHXXRatio1 = BrHXXRatio - 1.0;
11025 dBrHXXRatio2 = 0.0;
11026 } else if (fstate == 3){
11027 BrHXXRatio = (myNPbase->BrHbbRatio());
11028 dBrHXXRatio1 = BrHXXRatio - 1.0;
11029 dBrHXXRatio2 = 0.0;
11030 } else if (fstate == 4){
11031 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11032 dBrHXXRatio1 = BrHXXRatio - 1.0;
11033 dBrHXXRatio2 = 0.0;
11034 } else if (fstate == 5){
11035 BrHXXRatio = (myNPbase->BrHtautauRatio());
11036 dBrHXXRatio1 = BrHXXRatio - 1.0;
11037 dBrHXXRatio2 = 0.0;
11038 } else {
11039 throw std::runtime_error("STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
11040 }
11041
11042 //-- Production x Decay:
11043 if ((this->getModel()).isModelLinearized()){
11044 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11045 } else if((this->getModel()).isModelNPquadratic()){
11046 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11047 } else {
11048 return weight*(muProd)*(BrHXXRatio);
11049 }
11050
11051}
11052// -----------------------------------------------------------------------------
11053
11054//AG:STXS2024
11055STXS12_ttH_pTH450_Inf::STXS12_ttH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11056: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11057{
11058 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11059 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
11060
11061}
11062
11064{
11065 //-- Production:
11066 double weight = 1.0; //If normalized to the SM
11067 double muProd = myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s);
11068 double muProd1 = muProd -1.0;
11069 double muProd2 = 0.0;
11070
11071 //-- Decay:
11072 double BrHXXRatio = 1.0;
11073 double dBrHXXRatio1 = 0.0;
11074 double dBrHXXRatio2 = 0.0;
11075 if (fstate==0){
11076 // Use for Cross-section [pb] with no Higgs-boson decay
11077 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11078 } else if (fstate == 1){
11079 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11080 dBrHXXRatio1 = BrHXXRatio - 1.0;
11081 dBrHXXRatio2 = 0.0;
11082 } else if (fstate == 2){
11083 BrHXXRatio = (myNPbase->BrHgagaRatio());
11084 dBrHXXRatio1 = BrHXXRatio - 1.0;
11085 dBrHXXRatio2 = 0.0;
11086 } else if (fstate == 3){
11087 BrHXXRatio = (myNPbase->BrHbbRatio());
11088 dBrHXXRatio1 = BrHXXRatio - 1.0;
11089 dBrHXXRatio2 = 0.0;
11090 } else if (fstate == 4){
11091 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11092 dBrHXXRatio1 = BrHXXRatio - 1.0;
11093 dBrHXXRatio2 = 0.0;
11094 } else if (fstate == 5){
11095 BrHXXRatio = (myNPbase->BrHtautauRatio());
11096 dBrHXXRatio1 = BrHXXRatio - 1.0;
11097 dBrHXXRatio2 = 0.0;
11098 } else {
11099 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
11100 }
11101
11102 //-- Production x Decay:
11103 if ((this->getModel()).isModelLinearized()){
11104 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11105 } else if((this->getModel()).isModelNPquadratic()){
11106 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11107 } else {
11108 return weight*(muProd)*(BrHXXRatio);
11109 }
11110
11111}
11112
11113// -----------------------------------------------------------------------------
11114
11115//AG:STXS2024
11116STXS12_ttH_pTH300_Inf_add::STXS12_ttH_pTH300_Inf_add(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11117: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11118{
11119 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11120 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
11121
11122}
11123
11125{
11126 //-- Production:
11127 double weight = 1.0; //If normalized to the SM
11128 //Since adding bins, include partial weigths of SM_predictions
11129 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11130 double muProd = (0.01903*myNPbase->STXS12_ttH_pTH300_450(sqrt_s)
11131 + 0.00538*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)) / (0.01903+0.00538);
11132 double muProd1 = (0.01903*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11133 + 0.00538*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0)) / (0.01903+0.00538);
11134 double muProd2 = 0.0;
11135
11136 //-- Decay:
11137 double BrHXXRatio = 1.0;
11138 double dBrHXXRatio1 = 0.0;
11139 double dBrHXXRatio2 = 0.0;
11140 if (fstate==0){
11141 // Use for Cross-section [pb] with no Higgs-boson decay
11142 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11143 } else if (fstate == 1){
11144 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11145 dBrHXXRatio1 = BrHXXRatio - 1.0;
11146 dBrHXXRatio2 = 0.0;
11147 } else if (fstate == 2){
11148 BrHXXRatio = (myNPbase->BrHgagaRatio());
11149 dBrHXXRatio1 = BrHXXRatio - 1.0;
11150 dBrHXXRatio2 = 0.0;
11151 } else if (fstate == 3){
11152 BrHXXRatio = (myNPbase->BrHbbRatio());
11153 dBrHXXRatio1 = BrHXXRatio - 1.0;
11154 dBrHXXRatio2 = 0.0;
11155 } else if (fstate == 4){
11156 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11157 dBrHXXRatio1 = BrHXXRatio - 1.0;
11158 dBrHXXRatio2 = 0.0;
11159 } else if (fstate == 5){
11160 BrHXXRatio = (myNPbase->BrHtautauRatio());
11161 dBrHXXRatio1 = BrHXXRatio - 1.0;
11162 dBrHXXRatio2 = 0.0;
11163 } else {
11164 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
11165 }
11166
11167 //-- Production x Decay:
11168 if ((this->getModel()).isModelLinearized()){
11169 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11170 } else if((this->getModel()).isModelNPquadratic()){
11171 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11172 } else {
11173 return weight*(muProd)*(BrHXXRatio);
11174 }
11175
11176}
11177
11178// -----------------------------------------------------------------------------
11179
11180//AG:STXS2024
11181STXS12_ttH::STXS12_ttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11182: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11183{
11184 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11185 throw std::runtime_error("STXS12_ttH called with a class whose parent is not NPbase");
11186
11187}
11188
11190{
11191 //-- Production:
11192 double weight = 1.0; //If normalized to the SM
11193 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11194 //Since adding bins, include partial weigths (SM_predictions)
11195 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
11200 + 0.00060*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11201 double muProd1 = ( 0.09779*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s)-1.0)
11202 + 0.13884*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0)
11203 + 0.05439*(myNPbase->STXS12_ttH_pTH120_200(sqrt_s)-1.0)
11204 + 0.05303*(myNPbase->STXS12_ttH_pTH200_300(sqrt_s)-1.0)
11205 + 0.00498*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11206 + 0.00060*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11207 double muProd2 = 0.0;
11208
11209 //-- Decay:
11210 double BrHXXRatio = 1.0;
11211 double dBrHXXRatio1 = 0.0;
11212 double dBrHXXRatio2 = 0.0;
11213 if (fstate==0){
11214 weight = 1.0;
11215 } else if (fstate == 1){
11216 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11217 dBrHXXRatio1 = BrHXXRatio - 1.0;
11218 dBrHXXRatio2 = 0.0;
11219 } else if (fstate == 2){
11220 BrHXXRatio = (myNPbase->BrHgagaRatio());
11221 dBrHXXRatio1 = BrHXXRatio - 1.0;
11222 dBrHXXRatio2 = 0.0;
11223 } else if (fstate == 3){
11224 BrHXXRatio = (myNPbase->BrHbbRatio());
11225 dBrHXXRatio1 = BrHXXRatio - 1.0;
11226 dBrHXXRatio2 = 0.0;
11227 } else if (fstate == 4){
11228 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11229 dBrHXXRatio1 = BrHXXRatio - 1.0;
11230 dBrHXXRatio2 = 0.0;
11231 } else if (fstate == 5){
11232 BrHXXRatio = (myNPbase->BrHtautauRatio());
11233 dBrHXXRatio1 = BrHXXRatio - 1.0;
11234 dBrHXXRatio2 = 0.0;
11235 } else if (fstate == 6){
11236 BrHXXRatio = (myNPbase->BrHWWRatio());
11237 dBrHXXRatio1 = BrHXXRatio - 1.0;
11238 dBrHXXRatio2 = 0.0;
11239 } else if (fstate == 7){
11240 BrHXXRatio = (myNPbase->BrHZZRatio());
11241 dBrHXXRatio1 = BrHXXRatio - 1.0;
11242 dBrHXXRatio2 = 0.0;
11243 } else {
11244 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
11245 }
11246
11247 //-- Production x Decay:
11248 if ((this->getModel()).isModelLinearized()){
11249 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11250 } else if((this->getModel()).isModelNPquadratic()){
11251 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11252 } else {
11253 return weight*(muProd)*(BrHXXRatio);
11254 }
11255
11256}
11257
11258// -----------------------------------------------------------------------------
11259
11260//AG:STXS2024
11261STXS12_tH::STXS12_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11262: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11263{
11264 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11265 throw std::runtime_error("STXS12_tH called with a class whose parent is not NPbase");
11266
11267}
11268
11269double STXS12_tH::computeThValue() //AG:modified
11270{
11271 //-- Production:
11272 double weight = 1.0; //If normalized to the SM
11273 double muProd = myNPbase->STXS12_tH(sqrt_s);
11274 double muProd1 = muProd -1.0;
11275 double muProd2 = 0.0;
11276
11277 //-- Decay:
11278 double BrHXXRatio = 1.0;
11279 double dBrHXXRatio1 = 0.0;
11280 double dBrHXXRatio2 = 0.0;
11281 if (fstate==0){
11282 // Use for Cross-section [pb] with no Higgs-boson decay
11283 weight = 0.08207; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11284 } else if (fstate == 1){
11285 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11286 dBrHXXRatio1 = BrHXXRatio - 1.0;
11287 dBrHXXRatio2 = 0.0;
11288 } else if (fstate == 2){
11289 BrHXXRatio = (myNPbase->BrHgagaRatio());
11290 dBrHXXRatio1 = BrHXXRatio - 1.0;
11291 dBrHXXRatio2 = 0.0;
11292 } else if (fstate == 3){
11293 BrHXXRatio = (myNPbase->BrHbbRatio());
11294 dBrHXXRatio1 = BrHXXRatio - 1.0;
11295 dBrHXXRatio2 = 0.0;
11296 } else if (fstate == 4){
11297 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11298 dBrHXXRatio1 = BrHXXRatio - 1.0;
11299 dBrHXXRatio2 = 0.0;
11300 } else if (fstate == 5){
11301 BrHXXRatio = (myNPbase->BrHtautauRatio());
11302 dBrHXXRatio1 = BrHXXRatio - 1.0;
11303 dBrHXXRatio2 = 0.0;
11304 } else {
11305 throw std::runtime_error("STXS12_tH called with invalid argument for final state in fstate_i");
11306 }
11307
11308 //-- Production x Decay:
11309 if ((this->getModel()).isModelLinearized()){
11310 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11311 } else if((this->getModel()).isModelNPquadratic()){
11312 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11313 } else {
11314 return weight*(muProd)*(BrHXXRatio);
11315 }
11316
11317
11318}
11319
11320// -----------------------------------------------------------------------------
11321
11322
11323//-----------------------------------------------------------------------------------------
11324//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
11325//-----------------------------------------------------------------------------------------
11326
11327
11328muTHUggHgaga::muTHUggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11329: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11330{
11331 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11332 throw std::runtime_error("muTHUggHgaga called with a class whose parent is not NPbase");
11333}
11334
11336{
11337 return myNPbase->muTHUggHgaga(sqrt_s);
11338}
11339
11340
11341muTHUVBFHgaga::muTHUVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11342: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11343{
11344 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11345 throw std::runtime_error("muTHUVBFHgaga called with a class whose parent is not NPbase");
11346}
11347
11349{
11350 return myNPbase->muTHUVBFHgaga(sqrt_s);
11351}
11352
11353muTHUZHgaga::muTHUZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11354: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11355{
11356 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11357 throw std::runtime_error("muTHUZHgaga called with a class whose parent is not NPbase");
11358}
11359
11361{
11362 return myNPbase->muTHUZHgaga(sqrt_s);
11363}
11364
11365muTHUWHgaga::muTHUWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11366: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11367{
11368 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11369 throw std::runtime_error("muTHUWHgaga called with a class whose parent is not NPbase");
11370}
11371
11373{
11374 return myNPbase->muTHUWHgaga(sqrt_s);
11375}
11376
11377muTHUVHgaga::muTHUVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11378: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11379{
11380 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11381 throw std::runtime_error("muTHUVHgaga called with a class whose parent is not NPbase");
11382}
11383
11385{
11386 return myNPbase->muTHUVHgaga(sqrt_s);
11387}
11388
11389muTHUttHgaga::muTHUttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11390: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11391{
11392 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11393 throw std::runtime_error("muTHUttHgaga called with a class whose parent is not NPbase");
11394}
11395
11397{
11398 return myNPbase->muTHUttHgaga(sqrt_s);
11399}
11400
11401muTHUggHZga::muTHUggHZga(const StandardModel& SM_i, const double sqrt_s_i)
11402: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11403{
11404 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11405 throw std::runtime_error("muTHUggHZga called with a class whose parent is not NPbase");
11406}
11407
11409{
11410 return myNPbase->muTHUggHZga(sqrt_s);
11411}
11412
11413muTHUggHZgamumu::muTHUggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
11414: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11415{
11416 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11417 throw std::runtime_error("muTHUggHZgamumu called with a class whose parent is not NPbase");
11418}
11419
11421{
11422 return (myNPbase->muTHUggHZgamumu(sqrt_s));
11423}
11424
11425muTHUVBFHZga::muTHUVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
11426: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11427{
11428 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11429 throw std::runtime_error("muTHUVBFHZga called with a class whose parent is not NPbase");
11430}
11431
11433{
11434
11435 return myNPbase->muTHUVBFHZga(sqrt_s);
11436}
11437
11438muTHUZHZga::muTHUZHZga(const StandardModel& SM_i, const double sqrt_s_i)
11439: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11440{
11441 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11442 throw std::runtime_error("muTHUZHZga called with a class whose parent is not NPbase");
11443}
11444
11446{
11447 return myNPbase->muTHUZHZga(sqrt_s);
11448}
11449
11450muTHUWHZga::muTHUWHZga(const StandardModel& SM_i, const double sqrt_s_i)
11451: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11452{
11453 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11454 throw std::runtime_error("muTHUWHZga called with a class whose parent is not NPbase");
11455}
11456
11458{
11459 return myNPbase->muTHUWHZga(sqrt_s);
11460}
11461
11462muTHUVHZga::muTHUVHZga(const StandardModel& SM_i, const double sqrt_s_i)
11463: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11464{
11465 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11466 throw std::runtime_error("muTHUVHZga called with a class whose parent is not NPbase");
11467}
11468
11470{
11471 return myNPbase->muTHUVHZga(sqrt_s);
11472}
11473
11474muTHUttHZga::muTHUttHZga(const StandardModel& SM_i, const double sqrt_s_i)
11475: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11476{
11477 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11478 throw std::runtime_error("muTHUttHZga called with a class whose parent is not NPbase");
11479}
11480
11482{
11483 return myNPbase->muTHUttHZga(sqrt_s);
11484}
11485
11486muTHUggHZZ::muTHUggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11487: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11488{
11489 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11490 throw std::runtime_error("muTHUggHZZ called with a class whose parent is not NPbase");
11491}
11492
11494{
11495 return myNPbase->muTHUggHZZ(sqrt_s);
11496}
11497
11498muTHUVBFHZZ::muTHUVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11499: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11500{
11501 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11502 throw std::runtime_error("muTHUVBFHZZ called with a class whose parent is not NPbase");
11503}
11504
11506{
11507 return myNPbase->muTHUVBFHZZ(sqrt_s);
11508}
11509
11510muTHUZHZZ::muTHUZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11511: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11512{
11513 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11514 throw std::runtime_error("muTHUZHZZ called with a class whose parent is not NPbase");
11515}
11516
11518{
11519 return myNPbase->muTHUZHZZ(sqrt_s);
11520}
11521
11522muTHUWHZZ::muTHUWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11523: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11524{
11525 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11526 throw std::runtime_error("muTHUWHZZ called with a class whose parent is not NPbase");
11527}
11528
11530{
11531 return myNPbase->muTHUWHZZ(sqrt_s);
11532}
11533
11534muTHUVHZZ::muTHUVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11535: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11536{
11537 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11538 throw std::runtime_error("muTHUVHZZ called with a class whose parent is not NPbase");
11539}
11540
11542{
11543 return myNPbase->muTHUVHZZ(sqrt_s);
11544}
11545
11546muTHUttHZZ::muTHUttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11547: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11548{
11549 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11550 throw std::runtime_error("muTHUttHZZ called with a class whose parent is not NPbase");
11551}
11552
11554{
11555 return myNPbase->muTHUttHZZ(sqrt_s);
11556}
11557
11558muTHUggHZZ4l::muTHUggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11559: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11560{
11561 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11562 throw std::runtime_error("muTHUggHZZ4l called with a class whose parent is not NPbase");
11563}
11564
11566{
11567 return myNPbase->muTHUggHZZ4l(sqrt_s);
11568}
11569
11570muTHUggHZZ4mu::muTHUggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
11571: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11572{
11573 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11574 throw std::runtime_error("muTHUggHZZ4mu called with a class whose parent is not NPbase");
11575}
11576
11578{
11579 return (myNPbase->muTHUggHZZ4mu(sqrt_s));
11580}
11581
11582muTHUVBFHZZ4l::muTHUVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11583: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11584{
11585 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11586 throw std::runtime_error("muTHUVBFHZZ4l called with a class whose parent is not NPbase");
11587}
11588
11590{
11591 return myNPbase->muTHUVBFHZZ4l(sqrt_s);
11592}
11593
11594muTHUZHZZ4l::muTHUZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11595: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11596{
11597 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11598 throw std::runtime_error("muTHUZHZZ4l called with a class whose parent is not NPbase");
11599}
11600
11602{
11603 return myNPbase->muTHUZHZZ4l(sqrt_s);
11604}
11605
11606muTHUWHZZ4l::muTHUWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11607: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11608{
11609 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11610 throw std::runtime_error("muTHUWHZZ4l called with a class whose parent is not NPbase");
11611}
11612
11614{
11615 return myNPbase->muTHUWHZZ4l(sqrt_s);
11616}
11617
11618muTHUVHZZ4l::muTHUVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11619: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11620{
11621 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11622 throw std::runtime_error("muTHUVHZZ4l called with a class whose parent is not NPbase");
11623}
11624
11626{
11627 return myNPbase->muTHUVHZZ4l(sqrt_s);
11628}
11629
11630muTHUttHZZ4l::muTHUttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11631: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11632{
11633 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11634 throw std::runtime_error("muTHUttHZZ4l called with a class whose parent is not NPbase");
11635}
11636
11638{
11639 return myNPbase->muTHUttHZZ4l(sqrt_s);
11640}
11641
11642muTHUggHWW::muTHUggHWW(const StandardModel& SM_i, const double sqrt_s_i)
11643: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11644{
11645 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11646 throw std::runtime_error("muTHUggHWW called with a class whose parent is not NPbase");
11647}
11648
11650{
11651 return myNPbase->muTHUggHWW(sqrt_s);
11652}
11653
11654muTHUVBFHWW::muTHUVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
11655: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11656{
11657 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11658 throw std::runtime_error("muTHUVBFHWW called with a class whose parent is not NPbase");
11659}
11660
11662{
11663 return myNPbase->muTHUVBFHWW(sqrt_s);
11664}
11665
11666muTHUZHWW::muTHUZHWW(const StandardModel& SM_i, const double sqrt_s_i)
11667: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11668{
11669 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11670 throw std::runtime_error("muTHUZHWW called with a class whose parent is not NPbase");
11671}
11672
11674{
11675 return myNPbase->muTHUZHWW(sqrt_s);
11676}
11677
11678muTHUWHWW::muTHUWHWW(const StandardModel& SM_i, const double sqrt_s_i)
11679: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11680{
11681 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11682 throw std::runtime_error("muTHUWHWW called with a class whose parent is not NPbase");
11683}
11684
11686{
11687 return myNPbase->muTHUWHWW(sqrt_s);
11688}
11689
11690muTHUVHWW::muTHUVHWW(const StandardModel& SM_i, const double sqrt_s_i)
11691: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11692{
11693 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11694 throw std::runtime_error("muTHUVHWW called with a class whose parent is not NPbase");
11695}
11696
11698{
11699 return myNPbase->muTHUVHWW(sqrt_s);
11700}
11701
11702muTHUttHWW::muTHUttHWW(const StandardModel& SM_i, const double sqrt_s_i)
11703: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11704{
11705 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11706 throw std::runtime_error("muTHUttHWW called with a class whose parent is not NPbase");
11707}
11708
11710{
11711 return myNPbase->muTHUttHWW(sqrt_s);
11712}
11713
11714muTHUggHWW2l2v::muTHUggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
11715: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11716{
11717 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11718 throw std::runtime_error("muTHUggHWW2l2v called with a class whose parent is not NPbase");
11719}
11720
11722{
11724}
11725
11726muTHUVBFHWW2l2v::muTHUVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
11727: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11728{
11729 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11730 throw std::runtime_error("muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
11731}
11732
11734{
11736}
11737
11738muTHUZHWW2l2v::muTHUZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
11739: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11740{
11741 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11742 throw std::runtime_error("muTHUZHWW2l2v called with a class whose parent is not NPbase");
11743}
11744
11746{
11747 return myNPbase->muTHUZHWW2l2v(sqrt_s);
11748}
11749
11750muTHUWHWW2l2v::muTHUWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
11751: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11752{
11753 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11754 throw std::runtime_error("muTHUWHWW2l2v called with a class whose parent is not NPbase");
11755}
11756
11758{
11759 return myNPbase->muTHUWHWW2l2v(sqrt_s);
11760}
11761
11762muTHUVHWW2l2v::muTHUVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
11763: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11764{
11765 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11766 throw std::runtime_error("muTHUVHWW2l2v called with a class whose parent is not NPbase");
11767}
11768
11770{
11771 return myNPbase->muTHUVHWW2l2v(sqrt_s);
11772}
11773
11774muTHUttHWW2l2v::muTHUttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
11775: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11776{
11777 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11778 throw std::runtime_error("muTHUttHWW2l2v called with a class whose parent is not NPbase");
11779}
11780
11782{
11784}
11785
11786muTHUggHmumu::muTHUggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
11787: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11788{
11789 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11790 throw std::runtime_error("muTHUggHmumu called with a class whose parent is not NPbase");
11791}
11792
11794{
11795 return myNPbase->muTHUggHmumu(sqrt_s);
11796}
11797
11798muTHUVBFHmumu::muTHUVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
11799: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11800{
11801 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11802 throw std::runtime_error("muTHUVBFHmumu called with a class whose parent is not NPbase");
11803}
11804
11806{
11807 return myNPbase->muTHUVBFHmumu(sqrt_s);
11808}
11809
11810muTHUZHmumu::muTHUZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
11811: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11812{
11813 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11814 throw std::runtime_error("muTHUZHmumu called with a class whose parent is not NPbase");
11815}
11816
11818{
11819 return myNPbase->muTHUZHmumu(sqrt_s);
11820}
11821
11822muTHUWHmumu::muTHUWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
11823: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11824{
11825 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11826 throw std::runtime_error("muTHUWHmumu called with a class whose parent is not NPbase");
11827}
11828
11830{
11831 return myNPbase->muTHUWHmumu(sqrt_s);
11832}
11833
11834muTHUVHmumu::muTHUVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
11835: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11836{
11837 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11838 throw std::runtime_error("muTHUVHmumu called with a class whose parent is not NPbase");
11839}
11840
11842{
11843 return myNPbase->muTHUVHmumu(sqrt_s);
11844}
11845
11846muTHUttHmumu::muTHUttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
11847: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11848{
11849 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11850 throw std::runtime_error("muTHUttHmumu called with a class whose parent is not NPbase");
11851}
11852
11854{
11855 return myNPbase->muTHUttHmumu(sqrt_s);
11856}
11857
11858muTHUggHtautau::muTHUggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
11859: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11860{
11861 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11862 throw std::runtime_error("muTHUggHtautau called with a class whose parent is not NPbase");
11863}
11864
11866{
11868}
11869
11870muTHUVBFHtautau::muTHUVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
11871: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11872{
11873 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11874 throw std::runtime_error("muTHUVBFHtautau called with a class whose parent is not NPbase");
11875}
11876
11878{
11880}
11881
11882muTHUZHtautau::muTHUZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
11883: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11884{
11885 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11886 throw std::runtime_error("muTHUZHtautau called with a class whose parent is not NPbase");
11887}
11888
11890{
11891 return myNPbase->muTHUZHtautau(sqrt_s);
11892}
11893
11894muTHUWHtautau::muTHUWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
11895: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11896{
11897 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11898 throw std::runtime_error("muTHUWHtautau called with a class whose parent is not NPbase");
11899}
11900
11902{
11903 return myNPbase->muTHUWHtautau(sqrt_s);
11904}
11905
11906muTHUVHtautau::muTHUVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
11907: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11908{
11909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11910 throw std::runtime_error("muTHUVHtautau called with a class whose parent is not NPbase");
11911}
11912
11914{
11915 return myNPbase->muTHUVHtautau(sqrt_s);
11916}
11917
11918muTHUttHtautau::muTHUttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
11919: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11920{
11921 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11922 throw std::runtime_error("muTHUttHtautau called with a class whose parent is not NPbase");
11923}
11924
11926{
11928}
11929
11930muTHUggHbb::muTHUggHbb(const StandardModel& SM_i, const double sqrt_s_i)
11931: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11932{
11933 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11934 throw std::runtime_error("muTHUggHbb called with a class whose parent is not NPbase");
11935}
11936
11938{
11939 return myNPbase->muTHUggHbb(sqrt_s);
11940}
11941
11942muTHUVBFHbb::muTHUVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
11943: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11944{
11945 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11946 throw std::runtime_error("muTHUVBFHbb called with a class whose parent is not NPbase");
11947}
11948
11950{
11951 return myNPbase->muTHUVBFHbb(sqrt_s);
11952}
11953
11954muTHUZHbb::muTHUZHbb(const StandardModel& SM_i, const double sqrt_s_i)
11955: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11956{
11957 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11958 throw std::runtime_error("muTHUZHbb called with a class whose parent is not NPbase");
11959}
11960
11962{
11963 return myNPbase->muTHUZHbb(sqrt_s);
11964}
11965
11966muTHUWHbb::muTHUWHbb(const StandardModel& SM_i, const double sqrt_s_i)
11967: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11968{
11969 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11970 throw std::runtime_error("muTHUWHbb called with a class whose parent is not NPbase");
11971}
11972
11974{
11975 return myNPbase->muTHUWHbb(sqrt_s);
11976}
11977
11978muTHUVHbb::muTHUVHbb(const StandardModel& SM_i, const double sqrt_s_i)
11979: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11980{
11981 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11982 throw std::runtime_error("muTHUVHbb called with a class whose parent is not NPbase");
11983}
11984
11986{
11987 return myNPbase->muTHUVHbb(sqrt_s);
11988}
11989
11990muTHUttHbb::muTHUttHbb(const StandardModel& SM_i, const double sqrt_s_i)
11991: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11992{
11993 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11994 throw std::runtime_error("muTHUttHbb called with a class whose parent is not NPbase");
11995}
11996
11998{
11999 return myNPbase->muTHUttHbb(sqrt_s);
12000}
12001
12002
12003muTHUVBFBRinv::muTHUVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12004: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12005{
12006 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12007 throw std::runtime_error("muTHUVBFBRinv called with a class whose parent is not NPbase");
12008}
12009
12011{
12012
12013 return (myNPbase->muTHUVBFBRinv(sqrt_s));
12014
12015}
12016
12017muTHUVBFHinv::muTHUVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
12018: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12019{
12020 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12021 throw std::runtime_error("muTHUVBFHinv called with a class whose parent is not NPbase");
12022}
12023
12025{
12026
12027 return (myNPbase->muTHUVBFHinv(sqrt_s));
12028
12029}
12030
12031
12032muTHUVHBRinv::muTHUVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12033: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12034{
12035 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12036 throw std::runtime_error("muTHUVHBRinv called with a class whose parent is not NPbase");
12037}
12038
12040{
12041
12042 return (myNPbase->muTHUVHBRinv(sqrt_s));
12043
12044}
12045
12046muTHUVHinv::muTHUVHinv(const StandardModel& SM_i, const double sqrt_s_i)
12047: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12048{
12049 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12050 throw std::runtime_error("muTHUVHinv called with a class whose parent is not NPbase");
12051}
12052
12054{
12055 return (myNPbase->muTHUVHinv(sqrt_s));
12056}
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
const NPbase * myNPbase
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
const NPbase * myNPbase
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
virtual const double muggHbb(const double sqrt_s) const
Definition: NPbase.h:1647
virtual const double muVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1571
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3699
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3304
virtual const double cbminuscc() const
Definition: NPbase.h:2493
virtual const double muTHUZHmumu(const double sqrt_s) const
Definition: NPbase.h:2679
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3974
virtual const double deltaGammaHtautauRatio1() const
Definition: NPbase.h:1828
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4064
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2166
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:972
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3595
virtual const double muTHUttHWW(const double sqrt_s) const
Definition: NPbase.h:2643
virtual const double muTHUttHZga(const double sqrt_s) const
Definition: NPbase.h:2569
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2274
virtual const double muTHUttHbb(const double sqrt_s) const
Definition: NPbase.h:2739
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3710
virtual const double muggHZga(const double sqrt_s) const
Definition: NPbase.h:1442
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3084
virtual const double cVpluscb() const
Definition: NPbase.h:2475
virtual const double deltaGammaHtautauRatio2() const
Definition: NPbase.h:1832
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3604
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1191
virtual const double muttHptH_HWW(const double sqrt_s) const
Definition: NPbase.h:1551
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:947
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3771
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3857
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3689
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3130
virtual const double delta_mutH_2(const double sqrt_s) const
Definition: NPbase.h:1751
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
Definition: NPbase.h:1226
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
Definition: NPbase.h:923
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1916
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3803
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1331
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1022
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3179
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1367
virtual const double muttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1518
virtual const double muVHZga(const double sqrt_s) const
Definition: NPbase.h:1458
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1619
virtual const double muTHUZHZZ(const double sqrt_s) const
Definition: NPbase.h:2581
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3333
virtual const double muZHmumu(const double sqrt_s) const
Definition: NPbase.h:1587
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3956
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
Definition: NPbase.h:3481
virtual const double ccminusctau() const
Definition: NPbase.h:2511
virtual const double muTHUttHZZ(const double sqrt_s) const
Definition: NPbase.h:2593
virtual const double mueeZH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1090
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3848
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3209
virtual const double muVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:1583
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4091
virtual const double muggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1498
virtual const double delta_muZH_2(const double sqrt_s) const
Definition: NPbase.h:1724
virtual const double cgaplusct() const
Definition: NPbase.h:2457
virtual const double muTHUVBFBRinv(const double sqrt_s) const
Definition: NPbase.h:2744
virtual const double muTHUVBFHZga(const double sqrt_s) const
Definition: NPbase.h:2553
virtual const double deltaGammaHbbRatio2() const
Definition: NPbase.h:1814
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1056
virtual const double muttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1575
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3121
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4073
virtual const double STXS12_qqHqq_VH_had_Nj2(const double sqrt_s) const
The STXS bin , VH-had Ref. 2402.05742.
Definition: NPbase.h:3793
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1906
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
Definition: NPbase.h:1271
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3812
virtual const double muTHUVHBRinv(const double sqrt_s) const
Definition: NPbase.h:2754
virtual const double delta_mutH_1(const double sqrt_s) const
Definition: NPbase.h:1747
virtual const double muTHUZHgaga(const double sqrt_s) const
Definition: NPbase.h:2533
virtual const double muTHUggHZZ(const double sqrt_s) const
Definition: NPbase.h:2573
virtual const double muTHUVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:2577
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3490
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3753
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1607
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3866
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3902
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2647
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3159
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3929
virtual const double muVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:1474
virtual const double muTHUggHWW(const double sqrt_s) const
Definition: NPbase.h:2623
virtual const double cgplusct() const
Definition: NPbase.h:2448
virtual const double muttHtautau(const double sqrt_s) const
Definition: NPbase.h:1639
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3444
virtual const double muTHUggHZga(const double sqrt_s) const
Definition: NPbase.h:2549
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1283
virtual const double muTHUZHbb(const double sqrt_s) const
Definition: NPbase.h:2727
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3722
virtual const double muVBFHWW(const double sqrt_s) const
Definition: NPbase.h:1531
virtual const double muWHWW(const double sqrt_s) const
Definition: NPbase.h:1539
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4010
virtual const double muVBFHZga(const double sqrt_s) const
Definition: NPbase.h:1446
virtual const double muVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1559
virtual const double deltaGammaTotalRatio1() const
Definition: NPbase.h:1846
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3577
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
Definition: NPbase.h:3457
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3893
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3417
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2067
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2031
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2009
virtual const double muggHgaga(const double sqrt_s) const
Definition: NPbase.h:1384
virtual const double muVHcc(const double sqrt_s) const
Definition: NPbase.h:1679
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1140
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3517
virtual const double muttHptH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1402
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3313
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:1926
virtual const double deltaGammaHZgaRatio2() const
Definition: NPbase.h:1805
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3499
virtual const double deltaGammaHmumuRatio1() const
Definition: NPbase.h:1819
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3965
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4001
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3372
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3323
virtual const double muTHUWHbb(const double sqrt_s) const
Definition: NPbase.h:2731
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3353
virtual const double muTHUVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2614
virtual const double muppHmumu(const double sqrt_s) const
Definition: NPbase.h:1683
virtual const double muTHUVHinv(const double sqrt_s) const
Definition: NPbase.h:2759
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2353
virtual const double delta_muttH_2(const double sqrt_s) const
Definition: NPbase.h:1742
virtual const double muZHZga(const double sqrt_s) const
Definition: NPbase.h:1450
virtual const double deltaGammaHmumuRatio2() const
Definition: NPbase.h:1823
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3103
virtual const double muZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1563
virtual const double muttHWW(const double sqrt_s) const
Definition: NPbase.h:1547
virtual const double muVHZZ(const double sqrt_s) const
Definition: NPbase.h:1486
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4118
virtual const double deltaGammaHZgaRatio1() const
Definition: NPbase.h:1801
virtual const double deltaGammaHWWRatio1() const
Definition: NPbase.h:1774
virtual const double muTHUVHgaga(const double sqrt_s) const
Definition: NPbase.h:2541
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3199
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1470
virtual const double delta_muggH_1(const double sqrt_s) const
Definition: NPbase.h:1693
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3343
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1067
virtual const double delta_muVBF_1(const double sqrt_s) const
Definition: NPbase.h:1702
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3640
virtual const double deltaGammaHZZRatio1() const
Definition: NPbase.h:1783
virtual const double muTHUVHWW(const double sqrt_s) const
Definition: NPbase.h:2639
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3408
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1896
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3218
virtual const double muWHZga(const double sqrt_s) const
Definition: NPbase.h:1454
virtual const double muTHUttHtautau(const double sqrt_s) const
Definition: NPbase.h:2715
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1611
virtual const double muttHptH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1494
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2663
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1296
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3508
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2403
virtual const double muTHUttHgaga(const double sqrt_s) const
Definition: NPbase.h:2545
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2283
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3074
virtual const double muggHmumu(const double sqrt_s) const
Definition: NPbase.h:1579
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:985
virtual const double muggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1555
virtual const double muttHptH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1643
virtual const double STXS12_ttH_pTH300_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4127
virtual const double muZHbb(const double sqrt_s) const
Definition: NPbase.h:1659
virtual const double deltaGammaTotalRatio2() const
Definition: NPbase.h:1850
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3744
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3295
virtual const double muWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1567
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3735
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3667
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3390
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3426
virtual const double muZHtautau(const double sqrt_s) const
Definition: NPbase.h:1627
virtual const double muTHUVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:2529
virtual const double deltaGammaHgagaRatio2() const
Definition: NPbase.h:1796
virtual const double muTHUWHWW(const double sqrt_s) const
Definition: NPbase.h:2635
virtual const double deltaGammaHgagaRatio1() const
Definition: NPbase.h:1792
virtual const double mutHgaga(const double sqrt_s) const
Definition: NPbase.h:1390
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2659
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3631
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1153
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3545
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1999
virtual const double delta_muttH_1(const double sqrt_s) const
Definition: NPbase.h:1738
virtual const double muZHgaga(const double sqrt_s) const
Definition: NPbase.h:1426
virtual const double UpperLimitZgammaC(const double sqrt_s) const
Definition: NPbase.h:2439
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2304
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3227
virtual const double muWHgaga(const double sqrt_s) const
Definition: NPbase.h:1430
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
Definition: NPbase.h:3465
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3255
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
Definition: NPbase.h:2373
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4136
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1876
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3649
virtual const double muVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1502
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1307
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
Definition: NPbase.h:1319
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3139
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3678
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1956
virtual const double muVBFHbb(const double sqrt_s) const
Definition: NPbase.h:1655
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3821
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:997
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3112
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
Definition: NPbase.h:2412
virtual const double muTHUVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:2675
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3622
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4019
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
Definition: NPbase.h:2764
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:1864
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3658
virtual const double muTHUWHtautau(const double sqrt_s) const
Definition: NPbase.h:2707
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2602
virtual const double muZHWW(const double sqrt_s) const
Definition: NPbase.h:1535
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3830
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3875
virtual const double cbminusctau() const
Definition: NPbase.h:2502
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2335
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
Definition: NPbase.h:1215
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2076
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:960
virtual const double muTHUttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2618
virtual const double muWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1510
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
Definition: NPbase.h:2421
virtual const double mueeZHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1127
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2667
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3762
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1010
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3613
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
Definition: NPbase.h:2364
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1396
virtual const double muWHbb(const double sqrt_s) const
Definition: NPbase.h:1663
virtual const double muVHWW(const double sqrt_s) const
Definition: NPbase.h:1543
virtual const double muTHUVHZZ(const double sqrt_s) const
Definition: NPbase.h:2589
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
Definition: NPbase.h:912
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3169
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
Definition: NPbase.h:1379
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3189
virtual const double muTHUWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2610
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3381
virtual const double deltaGammaHZZRatio2() const
Definition: NPbase.h:1787
virtual const double muWHtautau(const double sqrt_s) const
Definition: NPbase.h:1631
virtual const double muTHUggHtautau(const double sqrt_s) const
Definition: NPbase.h:2695
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3556
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3911
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1936
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3399
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2220
virtual const double muTHUVBFHinv(const double sqrt_s) const
Definition: NPbase.h:2749
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1651
virtual const double muTHUggHgaga(const double sqrt_s) const
Definition: NPbase.h:2524
virtual const double muVHbb(const double sqrt_s) const
Definition: NPbase.h:1667
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4082
virtual const double muTHUggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2598
virtual const double muttHgaga(const double sqrt_s) const
Definition: NPbase.h:1438
virtual const double muTHUggHbb(const double sqrt_s) const
Definition: NPbase.h:2719
virtual const double muTHUWHgaga(const double sqrt_s) const
Definition: NPbase.h:2537
virtual const double muWHmumu(const double sqrt_s) const
Definition: NPbase.h:1591
virtual const double muZHZZ(const double sqrt_s) const
Definition: NPbase.h:1478
virtual const double muttHZZ(const double sqrt_s) const
Definition: NPbase.h:1490
virtual const double deltaGammaHbbRatio1() const
Definition: NPbase.h:1810
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1045
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:4154
virtual const double muWHZZ(const double sqrt_s) const
Definition: NPbase.h:1482
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
Definition: NPbase.h:2383
virtual const double muggHtautau(const double sqrt_s) const
Definition: NPbase.h:1615
virtual const double muttHmumu(const double sqrt_s) const
Definition: NPbase.h:1599
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3568
virtual const double muggHZZ(const double sqrt_s) const
Definition: NPbase.h:1466
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2326
virtual const double muTHUVBFHWW(const double sqrt_s) const
Definition: NPbase.h:2627
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3938
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3275
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4037
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2393
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
Definition: NPbase.h:3473
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1989
virtual const double muVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:1623
virtual const double muTHUVHbb(const double sqrt_s) const
Definition: NPbase.h:2735
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1179
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1203
virtual const double delta_muVBF_2(const double sqrt_s) const
Definition: NPbase.h:1706
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3094
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
Definition: NPbase.h:3782
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4046
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
Definition: NPbase.h:1259
virtual const double muTHUggHZgamumu(const double sqrt_s) const
Definition: NPbase.h:2769
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3149
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3535
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1343
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3947
virtual const double muVHtautau(const double sqrt_s) const
Definition: NPbase.h:1635
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2313
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2175
virtual const double muttHZga(const double sqrt_s) const
Definition: NPbase.h:1462
virtual const double muTHUZHtautau(const double sqrt_s) const
Definition: NPbase.h:2703
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1969
virtual const double muVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:1422
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3839
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3586
virtual const double UpperLimitZgammaA(const double sqrt_s) const
Definition: NPbase.h:2430
virtual const double muTHUZHZga(const double sqrt_s) const
Definition: NPbase.h:2557
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1886
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2651
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1946
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1102
virtual const double delta_muZH_1(const double sqrt_s) const
Definition: NPbase.h:1720
virtual const double muVHmumu(const double sqrt_s) const
Definition: NPbase.h:1595
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3363
virtual const double muTHUVHmumu(const double sqrt_s) const
Definition: NPbase.h:2687
virtual const double cgminuscga() const
Definition: NPbase.h:2466
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
Definition: NPbase.h:3062
virtual const double delta_muggH_2(const double sqrt_s) const
Definition: NPbase.h:1697
virtual const double muTHUWHZZ(const double sqrt_s) const
Definition: NPbase.h:2585
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3884
virtual const double muTHUVHtautau(const double sqrt_s) const
Definition: NPbase.h:2711
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1078
virtual const double muppHZga(const double sqrt_s) const
Definition: NPbase.h:1687
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3246
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3265
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
Definition: NPbase.h:935
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: NPbase.h:1417
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2344
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
Definition: NPbase.h:901
virtual const double deltaGammaHWWRatio2() const
Definition: NPbase.h:1778
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4145
virtual const double muggHWW(const double sqrt_s) const
Definition: NPbase.h:1523
virtual const double cVplusctau() const
Definition: NPbase.h:2484
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2655
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3435
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1034
virtual const double delta_muWH_1(const double sqrt_s) const
Definition: NPbase.h:1711
virtual const double muTHUVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:2699
virtual const double muggHpbbH_HWW(const double sqrt_s) const
Definition: NPbase.h:1527
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4028
virtual const double delta_muWH_2(const double sqrt_s) const
Definition: NPbase.h:1715
virtual const double muttHbb(const double sqrt_s) const
Definition: NPbase.h:1671
virtual const double muVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1514
virtual const double muTHUWHZga(const double sqrt_s) const
Definition: NPbase.h:2561
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1237
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4100
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1166
virtual const double muTHUVBFHbb(const double sqrt_s) const
Definition: NPbase.h:2723
virtual const double muTHUWHmumu(const double sqrt_s) const
Definition: NPbase.h:2683
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3983
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1114
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3285
virtual const double muTHUZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2606
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4055
virtual const double muttHptH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1603
virtual const double muVHgaga(const double sqrt_s) const
Definition: NPbase.h:1434
virtual const double muttHptH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1675
virtual const double muTHUttHmumu(const double sqrt_s) const
Definition: NPbase.h:2691
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4109
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3237
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:1979
virtual const double muTHUggHmumu(const double sqrt_s) const
Definition: NPbase.h:2671
virtual const double muZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1506
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3526
virtual const double muTHUZHWW(const double sqrt_s) const
Definition: NPbase.h:2631
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1355
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3920
virtual const double muTHUVHZga(const double sqrt_s) const
Definition: NPbase.h:2565
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
unsigned int fstate
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_VH_had_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
unsigned int fstate
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
Definition: ThObservable.h:25
const StandardModel & getModel()
A get method to get the model.
Definition: ThObservable.h:100
const StandardModel & SM
A reference to an object of StandardMode class.
Definition: ThObservable.h:121
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
const NPbase * myNPbase
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
const NPbase * myNPbase
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const NPbase * myNPbase
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
double computeThValue()
const NPbase * myNPbase
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double Pol_em
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeZHBRinvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mueeZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeZHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double Pol_em
const double sqrt_s
const double Pol_ep
mueeZHWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
mueeZHZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
mueeZHZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const double Pol_ep
mueeZHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mueeZHccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_ep
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZHgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double Pol_em
mueeZHggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
mueeZHinvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
mueeZHmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double Pol_ep
mueeZHssPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeZHtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
double computeThValue()
const double sqrt_s
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase